tbarequest 0.0.3 → 0.2.0

package/dist/types/endpoints/teams.js

@@ -1,139 +1,162 @@
-import { z } from "zod";
 import { Award, Media, Team, Team_Robot, Team_Simple } from "../schemas/teams.js";
 import { Event, Event_Simple, Team_Event_Status } from "../schemas/events.js";
 import { District_List } from "../schemas/districts.js";
 import { Match, Match_Simple } from "../schemas/matches.js";
+import { type } from "arktype";
 export const teamEndpoints = {
     "/teams/{page_num}": {
-        schema: z.array(Team),
-        arguments: z.tuple([z.number()]),
+        schema: Team.array(),
+        arguments: type(["number"]),
     },
     "/teams/{page_num}/simple": {
-        schema: z.array(Team_Simple),
-        arguments: z.tuple([z.number()]),
+        schema: Team_Simple.array(),
+        arguments: type(["number"]),
     },
     "/teams/{page_num}/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.number()]),
+        schema: type("string[]"),
+        arguments: type(["number"]),
     },
     "/teams/{year}/{page_num}": {
-        schema: z.array(Team),
-        arguments: z.tuple([z.number(), z.number()]),
+        schema: Team.array(),
+        arguments: type(["number", "number"]),
     },
     "/teams/{year}/{page_num}/simple": {
-        schema: z.array(Team_Simple),
-        arguments: z.tuple([z.number(), z.number()]),
+        schema: Team_Simple.array(),
+        arguments: type(["number", "number"]),
     },
     "/teams/{year}/{page_num}/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.number(), z.number()]),
+        schema: type("string[]"),
+        arguments: type(["number", "number"]),
     },
     "/team/{team_key}": {
         schema: Team,
-        arguments: z.tuple([z.string()]),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/simple": {
         schema: Team_Simple,
-        arguments: z.tuple([z.string()]),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/history": {
-        schema: z.object({ events: z.array(Event), awards: z.array(Award) }),
-        arguments: z.tuple([z.string()]),
+        schema: type({ events: Event.array(), awards: Award.array() }),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/years_participated": {
-        schema: z.array(z.number()),
-        arguments: z.tuple([z.string()]),
+        schema: type("number[]"),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/districts": {
-        schema: z.array(District_List),
-        arguments: z.tuple([z.string()]),
+        schema: District_List.array(),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/robots": {
-        schema: z.array(Team_Robot),
-        arguments: z.tuple([z.string()]),
+        schema: Team_Robot.array(),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/events": {
-        schema: z.array(Event),
-        arguments: z.tuple([z.string()]),
+        schema: Event.array(),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/events/simple": {
-        schema: z.array(Event_Simple),
-        arguments: z.tuple([z.string()]),
+        schema: Event_Simple.array(),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/events/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string()]),
+        schema: type("string[]"),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/events/{year}": {
-        schema: z.array(Event),
-        arguments: z.tuple([z.string(), z.int()]),
+        schema: Event.array(),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/events/{year}/simple": {
-        schema: z.array(Event_Simple),
-        arguments: z.tuple([z.string(), z.int()]),
+        schema: Event_Simple.array(),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/events/{year}/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string(), z.int()]),
+        schema: type("string[]"),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/events/{year}/statuses": {
-        schema: z.record(z.string(), Team_Event_Status.nullable()),
-        arguments: z.tuple([z.string(), z.int()]),
+        schema: type({
+            "[string]": Team_Event_Status,
+        }),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/event/{event_key}/matches": {
-        schema: z.array(Match),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: Match.array(),
+        arguments: type(["string", "string"]),
+        transformMatch: ({ key: eventKey }, schema) => {
+            if (eventKey &&
+                parseInt(eventKey.slice(0, 4)) &&
+                Array.isArray(schema) &&
+                schema.every((v) => v && typeof v === "object")) {
+                for (const member of schema) {
+                    member["score_breakdown"]["yearOfCompetition"] = parseInt(eventKey.slice(0, 4));
+                }
+            }
+            return schema;
+        },
     },
     "/team/{team_key}/event/{event_key}/matches/simple": {
-        schema: z.array(Match_Simple),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: Match_Simple.array(),
+        arguments: type(["string", "string"]),
     },
     "/team/{team_key}/event/{event_key}/matches/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: type("string[]"),
+        arguments: type(["string", "string"]),
     },
     "/team/{team_key}/event/{event_key}/awards": {
-        schema: z.array(Award),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: Award.array(),
+        arguments: type(["string", "string"]),
     },
     "/team/{team_key}/event/{event_key}/status": {
-        schema: Team_Event_Status.nullable(),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: type(Team_Event_Status, "|", "null"),
+        arguments: type(["string", "string"]),
     },
     "/team/{team_key}/awards": {
-        schema: z.array(Award),
-        arguments: z.tuple([z.string()]),
+        schema: Award.array(),
+        arguments: type(["string"]),
     },
     "/team/{team_key}/awards/{year}": {
-        schema: z.array(Award),
-        arguments: z.tuple([z.string(), z.number()]),
+        schema: Award.array(),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/matches/{year}": {
-        schema: z.array(Match),
-        arguments: z.tuple([z.string(), z.number()]),
+        schema: Match.array(),
+        arguments: type(["string", "number"]),
+        transformMatch: ({ year }, schema) => {
+            if (year &&
+                Array.isArray(schema) &&
+                schema.every((v) => v && typeof v === "object")) {
+                for (const member of schema) {
+                    member["score_breakdown"]["yearOfCompetition"] = year;
+                }
+            }
+            return schema;
+        },
     },
     "/team/{team_key}/matches/{year}/simple": {
-        schema: z.array(Match_Simple),
-        arguments: z.tuple([z.string(), z.number()]),
+        schema: Match_Simple.array(),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/matches/{year}/keys": {
-        schema: z.array(z.string()),
-        arguments: z.tuple([z.string(), z.number()]),
+        schema: type("string[]"),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/media/{year}": {
-        schema: z.array(Media),
-        arguments: z.tuple([z.string(), z.number()]),
+        schema: Media.array(),
+        arguments: type(["string", "number"]),
     },
     "/team/{team_key}/media/tag/{media_tag}": {
-        schema: z.array(Media),
-        arguments: z.tuple([z.string(), z.string()]),
+        schema: Media.array(),
+        arguments: type(["string", "string"]),
     },
     "/team/{team_key}/media/tag/{media_tag}/{year}": {
-        schema: z.array(Media),
-        arguments: z.tuple([z.string(), z.string(), z.int()]),
+        schema: Media.array(),
+        arguments: type(["string", "string", "number"]),
     },
     "/team/{team_key}/social_media": {
-        schema: z.array(Media),
-        arguments: z.tuple([z.string()]),
+        schema: Media.array(),
+        arguments: type(["string"]),
     },
 };

package/dist/types/index.d.ts

@@ -1,7 +1,11 @@
-import { z } from "zod";
+import { Type } from "arktype";
 export type Endpoints = {
     [key: string]: {
-        schema: z.Schema;
-        arguments: z.Schema | null;
+        schema: Type;
+        arguments: Type<[...unknown[]]>;
+        transformMatch?: (data: {
+            year?: number;
+            key?: string;
+        }, schema: unknown) => unknown;
     };
 };

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

@@ -1,26 +1,25 @@
-import { z } from "zod";
-export declare const District_List: z.ZodObject<{
-    abbreviation: z.ZodString;
-    display_name: z.ZodString;
-    key: z.ZodString;
-    year: z.ZodInt;
+export declare const District_List: import("arktype/internal/methods/object.ts").ObjectType<{
+    abbreviation: string;
+    display_name: string;
+    key: string;
+    year: number;
 }, {}>;
-export declare const District_Ranking: 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;
-    }, {}>>>;
+export declare const District_Ranking: import("arktype/internal/methods/object.ts").ObjectType<{
+    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;
 }, {}>;
-export declare const District_Advancement: z.ZodObject<{
-    dcmp: z.ZodBoolean;
-    cmp: z.ZodBoolean;
+export declare const District_Advancement: import("arktype/internal/methods/object.ts").ObjectType<{
+    dcmp: boolean;
+    cmp: boolean;
 }, {}>;

package/dist/types/schemas/districts.js

@@ -1,26 +1,26 @@
-import { z } from "zod";
-export const District_List = z.object({
-    abbreviation: z.string(),
-    display_name: z.string(),
-    key: z.string(),
-    year: z.int(),
+import { type } from "arktype";
+export const District_List = type({
+    abbreviation: "string",
+    display_name: "string",
+    key: "string",
+    year: "number",
 });
-export const District_Ranking = z.object({
-    team_key: z.string(),
-    rank: z.int(),
-    rookie_bonus: z.int().optional(),
-    point_total: z.number(),
-    event_points: z.array(z.object({
-        district_cmp: z.boolean(),
-        total: z.number(),
-        alliance_points: z.number(),
-        elim_points: z.number(),
-        award_points: z.number(),
-        event_key: z.string(),
-        qual_points: z.number(),
-    })).optional(),
+export const District_Ranking = type({
+    team_key: "string",
+    rank: "number",
+    rookie_bonus: "number?",
+    point_total: "number",
+    event_point: type({
+        district_cmp: "boolean",
+        total: "number",
+        alliance_points: "number",
+        elim_points: "number",
+        award_points: "number",
+        event_key: "string",
+        qual_points: "number",
+    }).array().optional(),
 });
-export const District_Advancement = z.object({
-    dcmp: z.boolean(),
-    cmp: z.boolean(),
+export const District_Advancement = type({
+    dcmp: "boolean",
+    cmp: "boolean",
 });