tbarequest 0.0.2 → 0.1.0

package/README.md

@@ -2,10 +2,6 @@
 
 > Unofficial wrapper to request data from The Blue Alliance API
 
-
-> [!WARNING]  
-> This package relies on a beta version of Zod, so it might be unstable until Zod 4.0 comes out.
-
 ## Install
 ```bash
 npm install tbarequest

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { Result } from "./utils.js";
 import { TBAEndpoint, TBAEndpoints } from "./types/endpoints/index.js";
-export declare function createTBACaller(api_key: string): <T extends TBAEndpoint>(endpoint: T, ...args: z.infer<TBAEndpoints[T]["arguments"]>) => Promise<Result<z.infer<TBAEndpoints[T]["schema"]>>>;
+export declare function createTBACaller(api_key: string): <T extends TBAEndpoint>(endpoint: T, ...args: TBAEndpoints[T]["arguments"]["infer"]) => Promise<Result<TBAEndpoints[T]["schema"]["infer"]>>;

package/dist/index.js

@@ -1,5 +1,6 @@
 import { tryCatch } from "./utils.js";
 import { endpoints } from "./types/endpoints/index.js";
+import { ArkErrors } from "arktype";
 /*
  * Creates a function that can call the TBA api.
  * @see https://www.thebluealliance.com/apidocs/v3
@@ -36,11 +37,11 @@ async function TBA(endpoint, api_key, ...args) {
             data: null,
             error: new Error(`JSON didn't parse for endpoint ${endpoint}. Please contact the developers of the TBArequest package with this error: ${json.error.message}`),
         };
-    const schema = endpoints[endpoint].schema.safeParse(json.data);
-    if (!schema.success)
+    const schema = endpoints[endpoint].schema(json.data);
+    if (schema instanceof ArkErrors)
         return {
             data: null,
-            error: new Error(`Schema for endpoint ${endpoint} didn't work. Please contact the developers of the TBArequest package with this error: ${schema.error.message}`),
+            error: new Error(`Schema for endpoint ${endpoint} didn't work. Please contact the developers of the TBArequest package with this error: ${schema}`),
         };
-    return { data: schema.data, error: null };
+    return { data: schema, error: null };
 }

package/dist/types/endpoints/districts.d.ts

@@ -1,173 +1,161 @@
-import { z } from "zod";
 export declare const districtEndpoints: {
     "/districts/{year}": {
-        schema: z.ZodArray<z.ZodObject<{
-            abbreviation: z.ZodString;
-            display_name: z.ZodString;
-            key: z.ZodString;
-            year: z.ZodInt;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodInt], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            abbreviation: string;
+            display_name: string;
+            key: string;
+            year: number;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[number], {}>;
     };
     "/district/{district_abbreviation}/history": {
-        schema: z.ZodArray<z.ZodObject<{
-            abbreviation: z.ZodString;
-            display_name: z.ZodString;
-            key: z.ZodString;
-            year: z.ZodInt;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            abbreviation: string;
+            display_name: string;
+            key: string;
+            year: number;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/events": {
-        schema: z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            name: z.ZodString;
-            event_code: z.ZodString;
-            event_type: z.ZodInt;
-            district: z.ZodNullable<z.ZodObject<{
-                abbreviation: z.ZodString;
-                display_name: z.ZodString;
-                key: z.ZodString;
-                year: z.ZodInt;
-            }, {}>>;
-            city: z.ZodNullable<z.ZodString>;
-            state_prov: z.ZodNullable<z.ZodString>;
-            country: z.ZodNullable<z.ZodString>;
-            start_date: z.coerce.ZodCoercedDate;
-            end_date: z.coerce.ZodCoercedDate;
-            year: z.ZodInt;
-            short_name: z.ZodNullable<z.ZodString>;
-            event_type_string: z.ZodString;
-            week: z.ZodNullable<z.ZodNumber>;
-            address: z.ZodNullable<z.ZodString>;
-            postal_code: z.ZodNullable<z.ZodString>;
-            gmaps_place_id: z.ZodNullable<z.ZodString>;
-            gmaps_url: z.ZodNullable<z.ZodString>;
-            lat: z.ZodNullable<z.ZodNumber>;
-            lng: z.ZodNullable<z.ZodNumber>;
-            location_name: z.ZodNullable<z.ZodString>;
-            timezone: z.ZodNullable<z.ZodString>;
-            website: z.ZodNullable<z.ZodString>;
-            first_event_id: z.ZodNullable<z.ZodString>;
-            first_event_code: z.ZodNullable<z.ZodString>;
-            webcasts: z.ZodArray<z.ZodObject<{
-                type: z.ZodEnum<{
-                    youtube: "youtube";
-                    twitch: "twitch";
-                    ustream: "ustream";
-                    iframe: "iframe";
-                    html5: "html5";
-                    rtmp: "rtmp";
-                    livestream: "livestream";
-                    direct_link: "direct_link";
-                    mms: "mms";
-                    justin: "justin";
-                    stemtv: "stemtv";
-                    dacast: "dacast";
-                }>;
-                channel: z.ZodString;
-                date: z.ZodOptional<z.ZodNullable<z.coerce.ZodCoercedDate>>;
-                file: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, {}>>;
-            division_keys: z.ZodArray<z.ZodString>;
-            parent_event_key: z.ZodNullable<z.ZodString>;
-            playoff_type: z.ZodNullable<z.ZodInt>;
-            playoff_type_string: z.ZodNullable<z.ZodString>;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            key: string;
+            name: string;
+            event_code: string;
+            event_type: number;
+            district: {
+                abbreviation: string;
+                display_name: string;
+                key: string;
+                year: number;
+            } | null;
+            city: string | null;
+            state_prov: string | null;
+            country: string | null;
+            start_date: string;
+            end_date: string;
+            year: number;
+            short_name: string | null;
+            event_type_string: string;
+            week: number | null;
+            address: string | null;
+            postal_code: string | null;
+            gmaps_place_id: string | null;
+            gmaps_url: string | null;
+            lat: number | null;
+            lng: number | null;
+            location_name: string | null;
+            timezone: string | null;
+            website: string | null;
+            first_event_id: string | null;
+            first_event_code: string | null;
+            webcasts: {
+                type: "youtube" | "twitch" | "ustream" | "iframe" | "html5" | "rtmp" | "livestream" | "direct_link" | "mms" | "justin" | "stemtv" | "dacast";
+                channel: string;
+                date?: string | null | undefined;
+                file?: string | null | undefined;
+            }[];
+            division_keys: string[];
+            parent_event_key: string | null;
+            playoff_type: number | null;
+            playoff_type_string: string | null;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/awards": {
-        schema: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            award_type: z.ZodInt;
-            event_key: z.ZodString;
-            recipient_list: z.ZodArray<z.ZodObject<{
-                team_key: z.ZodNullable<z.ZodString>;
-                awardee: z.ZodNullable<z.ZodString>;
-            }, {}>>;
-            year: z.ZodInt;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            name: string;
+            award_type: number;
+            event_key: string;
+            recipient_list: {
+                team_key: string | null;
+                awardee: string | null;
+            }[];
+            year: number;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/events/simple": {
-        schema: z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            name: z.ZodString;
-            event_code: z.ZodString;
-            event_type: z.ZodInt;
-            district: z.ZodNullable<z.ZodObject<{
-                abbreviation: z.ZodString;
-                display_name: z.ZodString;
-                key: z.ZodString;
-                year: z.ZodInt;
-            }, {}>>;
-            city: z.ZodNullable<z.ZodString>;
-            state_prov: z.ZodNullable<z.ZodString>;
-            country: z.ZodNullable<z.ZodString>;
-            start_date: z.coerce.ZodCoercedDate;
-            end_date: z.coerce.ZodCoercedDate;
-            year: z.ZodInt;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            key: string;
+            name: string;
+            event_code: string;
+            event_type: number;
+            district: {
+                abbreviation: string;
+                display_name: string;
+                key: string;
+                year: number;
+            } | null;
+            city: string | null;
+            state_prov: string | null;
+            country: string | null;
+            start_date: string;
+            end_date: string;
+            year: number;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/events/keys": {
-        schema: z.ZodArray<z.ZodString>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<string[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/teams": {
-        schema: z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            team_number: z.ZodInt;
-            nickname: z.ZodString;
-            name: z.ZodString;
-            city: z.ZodNullable<z.ZodString>;
-            state_prov: z.ZodNullable<z.ZodString>;
-            country: z.ZodNullable<z.ZodString>;
-            postal_code: z.ZodNullable<z.ZodString>;
-            website: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            rookie_year: z.ZodNullable<z.ZodNumber>;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            key: string;
+            team_number: number;
+            nickname: string;
+            name: string;
+            city: string | null;
+            state_prov: string | null;
+            country: string | null;
+            postal_code: string | null;
+            rookie_year: number | null;
+            website?: string | null | undefined;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/teams/simple": {
-        schema: z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            team_number: z.ZodInt;
-            nickname: z.ZodString;
-            name: z.ZodString;
-            city: z.ZodNullable<z.ZodString>;
-            state_prov: z.ZodNullable<z.ZodString>;
-            country: z.ZodNullable<z.ZodString>;
-        }, {}>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<{
+            key: string;
+            team_number: number;
+            nickname: string;
+            name: string;
+            city: string | null;
+            state_prov: string | null;
+            country: string | null;
+        }[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/teams/keys": {
-        schema: z.ZodArray<z.ZodString>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype/internal/methods/array.ts").ArrayType<string[], {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/rankings": {
-        schema: z.ZodNullable<z.ZodArray<z.ZodObject<{
-            team_key: z.ZodString;
-            rank: z.ZodInt;
-            rookie_bonus: z.ZodOptional<z.ZodInt>;
-            point_total: z.ZodNumber;
-            event_points: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                district_cmp: z.ZodBoolean;
-                total: z.ZodNumber;
-                alliance_points: z.ZodNumber;
-                elim_points: z.ZodNumber;
-                award_points: z.ZodNumber;
-                event_key: z.ZodString;
-                qual_points: z.ZodNumber;
-            }, {}>>>;
-        }, {}>>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype").BaseType<{
+            team_key: string;
+            rank: number;
+            point_total: number;
+            rookie_bonus?: number | undefined;
+            event_point?: {
+                district_cmp: boolean;
+                total: number;
+                alliance_points: number;
+                elim_points: number;
+                award_points: number;
+                event_key: string;
+                qual_points: number;
+            }[] | undefined;
+        }[] | null, {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
     "/district/{district_key}/advancement": {
-        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodObject<{
-            dcmp: z.ZodBoolean;
-            cmp: z.ZodBoolean;
-        }, {}>>>;
-        arguments: z.ZodTuple<[z.ZodString], null>;
+        schema: import("arktype").BaseType<{
+            [x: string]: {
+                dcmp: boolean;
+                cmp: boolean;
+            };
+        } | null, {}>;
+        arguments: import("arktype/internal/methods/array.ts").ArrayType<[string], {}>;
     };
 };

package/dist/types/endpoints/districts.js

@@ -1,50 +1,50 @@
-import { z } from "zod";
 import { District_Advancement, District_List, District_Ranking } from "../schemas/districts.js";
 import { Event, Event_Simple } from "../schemas/events.js";
 import { Award, Team, Team_Simple } from "../schemas/teams.js";
+import { type } from "arktype";
 export const districtEndpoints = {
     "/districts/{year}": {
-        schema: z.array(District_List),
-        arguments: z.tuple([z.int()]),
+        schema: District_List.array(),
+        arguments: type(["number"]),
     },
     "/district/{district_abbreviation}/history": {
-        schema: z.array(District_List),
-        arguments: z.tuple([z.string()]),
+        schema: District_List.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/events": {
-        schema: z.array(Event),
-        arguments: z.tuple([z.string()]),
+        schema: Event.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/awards": {
-        schema: z.array(Award),
-        arguments: z.tuple([z.string()]),
+        schema: Award.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/events/simple": {
-        schema: z.array(Event_Simple),
-        arguments: z.tuple([z.string()]),
+        schema: Event_Simple.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/events/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string()]),
+        schema: type("string[]"),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/teams": {
-        schema: z.array(Team),
-        arguments: z.tuple([z.string()]),
+        schema: Team.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/teams/simple": {
-        schema: z.array(Team_Simple),
-        arguments: z.tuple([z.string()]),
+        schema: Team_Simple.array(),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/teams/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string()]),
+        schema: type("string[]"),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/rankings": {
-        schema: z.array(District_Ranking).nullable(),
-        arguments: z.tuple([z.string()]),
+        schema: type(District_Ranking.array(), "|", "null"),
+        arguments: type(["string"]),
     },
     "/district/{district_key}/advancement": {
-        schema: z.record(z.string(), District_Advancement).nullable(),
-        arguments: z.tuple([z.string()]),
+        schema: type({ "[string]": District_Advancement }, "|", "null"),
+        arguments: type(["string"]),
     },
 };