structured-outputs 0.1.0-beta.22 → 0.1.0-beta.23

package/esm/types/transform.d.ts

@@ -0,0 +1,3 @@
+import { Ty } from "./Ty.js";
+export declare function transform<T, P extends keyof any, R extends boolean, I>(ty: Ty<I, P, R>, transform: (value: I) => T): Ty<T, P, R>;
+//# sourceMappingURL=transform.d.ts.map

package/esm/types/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/types/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,EAAE,CAAC,SAAS,OAAO,EAAE,CAAC,EACpE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GACzB,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAEb"}

package/esm/types/transform.js

@@ -0,0 +1,5 @@
+import { Ty } from "./Ty.js";
+export function transform(ty, transform) {
+    return Ty((ref) => ref(ty), ty[""].root, (value) => transform(value));
+}
+//# sourceMappingURL=transform.js.map

package/esm/types/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../src/types/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,MAAM,UAAU,SAAS,CACvB,EAAe,EACf,SAA0B;IAE1B,OAAO,EAAE,CAAa,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,CAAC"}

package/esm/types/tuple.d.ts

@@ -0,0 +1,5 @@
+import { Ty } from "./Ty.js";
+export declare function tuple<F extends Ty[]>(...elements: F): Ty<{
+    [K in keyof F]: F[K]["T"];
+}, F[number]["P"], true>;
+//# sourceMappingURL=tuple.d.ts.map

package/esm/types/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../src/types/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,wBAAgB,KAAK,CAAC,CAAC,SAAS,EAAE,EAAE,EAClC,GAAG,QAAQ,EAAE,CAAC,GACb,EAAE,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;CAAE,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAYzD"}

package/esm/types/tuple.js

@@ -0,0 +1,11 @@
+import { Ty } from "./Ty.js";
+export function tuple(...elements) {
+    const { length } = elements;
+    return Ty((ref) => ({
+        type: "object",
+        properties: Object.fromEntries(Array.from({ length }, (_0, i) => [i, ref(elements[i])])),
+        additionalProperties: false,
+        required: Object.keys(Array.from({ length }, (_0, i) => i)),
+    }), true, (v) => Array.from({ length }, (_0, i) => elements[i][""].transform(v[i])));
+}
+//# sourceMappingURL=tuple.js.map

package/esm/types/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../src/types/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,MAAM,UAAU,KAAK,CACnB,GAAG,QAAW;IAEd,MAAM,EAAE,MAAM,EAAE,GAAG,QAAQ,CAAA;IAC3B,OAAO,EAAE,CACP,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACR,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC;QACzF,oBAAoB,EAAE,KAAK;QAC3B,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;KAC5D,CAAC,EACF,IAAI,EACJ,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAU,CACpF,CAAA;AACH,CAAC"}

package/esm/util/recombine.d.ts

@@ -0,0 +1,2 @@
+export declare function recombine(strings: TemplateStringsArray, values: Array<number | string>): string;
+//# sourceMappingURL=recombine.d.ts.map

package/esm/util/recombine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recombine.d.ts","sourceRoot":"","sources":["../../src/util/recombine.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAE/F"}

package/esm/util/recombine.js

@@ -0,0 +1,4 @@
+export function recombine(strings, values) {
+    return strings.reduce((acc, cur, i) => `${acc}${cur}${values[i] ?? ""}`, "");
+}
+//# sourceMappingURL=recombine.js.map

package/esm/util/recombine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recombine.js","sourceRoot":"","sources":["../../src/util/recombine.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAC,OAA6B,EAAE,MAA8B;IACrF,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;AAC9E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "structured-outputs",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.23",
   "description": "A library for working with OpenAI's structured outputs.",
   "repository": "github:harrysolovay/structured-outputs.git",
   "license": "Apache-2.0",

package/src/ResponseFormat.ts

@@ -1,25 +1,23 @@
-import type { ChatCompletion, ChatCompletionChoice, JsonSchema } from "./oai.js"
-import type { RootTy } from "./types/mod.js"
-import { recombineTaggedTemplateArgs } from "./util/recombineTaggedTemplateArgs.js"
+import type Openai from "openai"
+import type { Ty } from "./types/mod.js"
+import { recombine } from "./util/recombine.js"
 
 export interface ResponseFormat<T> {
   (template: TemplateStringsArray, ...quasis: Array<string>): ResponseFormat<T>
   type: "json_schema"
   /** The desired return type in JSON Schema. */
-  json_schema: JsonSchema
-  /** Parse the content of the first choice into a typed object. */
-  parseFirstChoice(completion: ChatCompletion): T
-  /** Parse all choice contents into an array of typed object. */
-  parseChoices(completion: ChatCompletion): Array<T>
+  json_schema: Openai.ResponseFormatJSONSchema["json_schema"]
+  /** Transform the content of the first choice into a typed object. */
+  into(completion: ChatCompletion): T
 }
 
-export function ResponseFormat<T>(name: string, ty: RootTy<T, never>): ResponseFormat<T> {
+export function ResponseFormat<T>(name: string, ty: Ty<T, never, true>): ResponseFormat<T> {
   return ResponseFormat_(name, ty)
 }
 
 function ResponseFormat_<T>(
   name: string,
-  ty: RootTy<T, never>,
+  ty: Ty<T, never>,
   description?: string,
 ): ResponseFormat<T> {
   return Object.assign(
@@ -27,7 +25,7 @@ function ResponseFormat_<T>(
       ResponseFormat_(
         name,
         ty,
-        description ? `${description} ${recombineTaggedTemplateArgs(template, quasis)}` : undefined,
+        description ? `${description} ${recombine(template, quasis)}` : undefined,
       ),
     {
       type: "json_schema" as const,
@@ -37,11 +35,8 @@ function ResponseFormat_<T>(
         schema: ty.schema(),
         strict: true,
       },
-      parseFirstChoice: (completion: ChatCompletion): T => {
-        return JSON.parse(ResponseFormat.unwrapFirstChoice(completion))
-      },
-      parseChoices: (completion: ChatCompletion): Array<T> => {
-        return ResponseFormat.unwrapChoices(completion).map((content) => JSON.parse(content))
+      into: (completion: ChatCompletion): T => {
+        return ty[""].transform(JSON.parse(ResponseFormat.unwrapFirstChoice(completion)))
       },
       toJSON() {
         const { type, json_schema } = this
@@ -64,7 +59,7 @@ export namespace ResponseFormat {
     return completions.choices.map(unwrapChoice)
   }
 
-  function unwrapChoice(choice: ChatCompletionChoice) {
+  function unwrapChoice(choice: Openai.Chat.Completions.ChatCompletion.Choice) {
     const { finish_reason, message } = choice
     if (finish_reason !== "stop") {
       throw new ResponseFormatUnwrapError(
@@ -87,3 +82,5 @@ export namespace ResponseFormat {
 export class ResponseFormatUnwrapError extends Error {
   override readonly name = "UnwrapResponseError"
 }
+
+type ChatCompletion = Openai.Chat.ChatCompletion

package/src/Tool.ts

@@ -1,18 +1,17 @@
-import type { RootTy, Schema } from "./types/mod.js"
-import { recombineTaggedTemplateArgs } from "./util/recombineTaggedTemplateArgs.js"
+import type { Schema, Ty } from "./types/mod.js"
+import { recombine } from "./util/recombine.js"
 
-/** @experimental */
-export function Tool<T>(name: string, ty: RootTy<T, never>): Tool<T> {
+export function Tool<T>(name: string, ty: Ty<T, never, true>): Tool<T> {
   return Tool_(name, ty)
 }
 
-function Tool_<T>(name: string, ty: RootTy<T, never>, description?: string): Tool<T> {
+function Tool_<T>(name: string, ty: Ty<T, never, true>, description?: string): Tool<T> {
   return Object.assign(
     (template: TemplateStringsArray, ...quasis: Array<string>) =>
       Tool_(
         name,
         ty,
-        description ? `${description} ${recombineTaggedTemplateArgs(template, quasis)}` : undefined,
+        description ? `${description} ${recombine(template, quasis)}` : undefined,
       ),
     {
       type: "function" as const,

package/src/types/Ty.ts

@@ -1,50 +1,91 @@
-import { phantoms } from "../util/phantoms.js"
-import type { Ref } from "./Ref.js"
-import type { RootTy } from "./RootTy.js"
+import { recombine } from "../util/recombine.js"
 
-export function Ty<T, P extends keyof any = never>(
-  toSchema: ToSchema,
+export interface Ty<T = any, P extends keyof any = keyof any, R extends boolean = boolean> {
+  <P2 extends Array<keyof any>>(
+    template: TemplateStringsArray,
+    ...placeheld: P2
+  ): Ty<T, P | P2[number], R>
+
+  /** The native TypeScript type. The runtime value is nonexistent. */
+  T: T
+  /** The literal types of the placeheld keys. The runtime value is nonexistent. */
+  P: P
+
+  "": {
+    subschema: Subschema
+    root: R
+    transform: (value: any) => any
+    context: Array<Context>
+    applied: Applied
+  }
+
+  /** Inject context into that which is placeheld. */
+  fill: <A extends Partial<Record<P, number | string>>>(
+    values: A,
+  ) => Ty<T, Exclude<P, keyof A>, R>
+
+  /** Get the corresponding JSON Schema. */
+  schema(this: Ty<T, never>): Schema
+}
+
+export function Ty<T, P extends keyof any, R extends boolean, I = T>(
+  subschema: Subschema,
+  root: R,
+  transform: (value: I) => T = (value) => value as never,
   context: Array<Context> = [],
   applied: Applied = {},
-): Ty<T, P> {
+): Ty<T, P, R> {
   return Object.assign(
     <P2 extends Array<keyof any>>(template: TemplateStringsArray, ...placeheld: P2) =>
-      Ty<T, P | P2[number]>(toSchema, [{ template, placeheld }, ...context], applied),
-    phantoms<{ T: T; P: P }>(),
+      Ty<T, P | P2[number], R, I>(
+        subschema,
+        root,
+        transform,
+        [{ template, placeheld }, ...context],
+        applied,
+      ),
+    {} as { T: T; P: P },
     {
-      "": { toSchema, context, applied },
+      "": {
+        subschema,
+        root,
+        transform,
+        context,
+        applied,
+      },
       fill: <A extends Partial<Record<P, string | number>>>(values: A) => {
-        return Ty<T, Exclude<P, keyof A>>(toSchema, context, { ...applied, ...values })
+        return Ty<T, Exclude<P, keyof A>, R, I>(subschema, root, transform, context, {
+          ...applied,
+          ...values,
+        })
       },
-      isRoot(): this is RootTy {
-        return false
+      schema(this: Ty<T, never>) {
+        return SubschemaFactory({})(this)
       },
     },
   )
 }
 
-export interface Ty<T = any, P extends keyof any = keyof any> {
-  <P2 extends Array<keyof any>>(
-    template: TemplateStringsArray,
-    ...placeheld: P2
-  ): Ty<T, P | P2[number]>
-  T: T
-  P: P
-  "": {
-    toSchema: ToSchema
-    context: Array<Context>
-    applied: Applied
+export type Subschema = (subschema: SubschemaFactory) => Schema
+
+export type SubschemaFactory = (ty: Ty) => Schema
+export function SubschemaFactory(applied: Applied): SubschemaFactory {
+  return (ty) => {
+    applied = { ...applied, ...ty[""].applied }
+    const description = ty[""].context
+      .map(({ template, placeheld }) => recombine(template, placeheld.map((k) => applied[k]!)))
+      .join(" ")
+    return {
+      ...ty[""].subschema(SubschemaFactory(applied)),
+      ...description ? { description } : {},
+    }
   }
-  fill: <A extends Partial<Record<P, number | string>>>(values: A) => Ty<T, Exclude<P, keyof A>>
-  isRoot(): this is RootTy
 }
 
-export type ToSchema = (ref: Ref) => Schema
-export type Schema = Record<string, unknown>
-
-export interface Context {
+interface Context {
   template: TemplateStringsArray
   placeheld: Array<keyof any>
 }
+type Applied = Record<keyof any, number | string>
 
-export type Applied = Record<keyof any, number | string>
+export type Schema = Record<string, unknown>

package/src/types/array.ts

@@ -1,8 +1,12 @@
 import { Ty } from "./Ty.js"
 
-export function array<E extends Ty>(element: E): Ty<Array<E["T"]>, E["P"]> {
-  return Ty((ref) => ({
-    type: "array",
-    items: ref(element),
-  }))
+export function array<E extends Ty>(element: E): Ty<Array<E["T"]>, E["P"], false> {
+  return Ty(
+    (ref) => ({
+      type: "array",
+      items: ref(element),
+    }),
+    false,
+    (value) => value.map(element[""].transform),
+  )
 }

package/src/types/constantUnion.ts

@@ -3,7 +3,7 @@ import { Ty } from "./Ty.js"
 
 export function constantUnion<M extends Array<number | string>>(
   ...members: M
-): Ty<M[number], never> {
+): Ty<M[number], never, false> {
   const [strings, numbers] = partition(members, (v) => typeof v === "string")
   return Ty(() => ({
     anyOf: [
@@ -20,5 +20,5 @@ export function constantUnion<M extends Array<number | string>>(
         }]
         : [],
     ],
-  }))
+  }), false)
 }

package/src/types/mod.ts

@@ -1,10 +1,9 @@
 export * from "./array.js"
-export * from "./constant.js"
 export * from "./constantUnion.js"
 export * from "./object.js"
 export * from "./primitives.js"
-export * from "./Ref.js"
-export * from "./RootTy.js"
 export * from "./std/mod.js"
 export * from "./taggedUnion.js"
+export * from "./transform.js"
+export * from "./tuple.js"
 export * from "./Ty.js"

package/src/types/object.ts

@@ -1,13 +1,19 @@
-import { RootTy } from "./RootTy.js"
-import type { Ty } from "./Ty.js"
+import { Ty } from "./Ty.js"
 
 export function object<F extends Record<string, Ty>>(
   fields: F,
-): RootTy<{ [K in keyof F]: F[K]["T"] }, F[keyof F]["P"]> {
-  return RootTy((ref) => ({
-    type: "object",
-    properties: Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, ref(v)])),
-    additionalProperties: false,
-    required: Object.keys(fields),
-  }))
+): Ty<{ [K in keyof F]: F[K]["T"] }, F[keyof F]["P"], true> {
+  return Ty(
+    (ref) => ({
+      type: "object",
+      properties: Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, ref(v)])),
+      additionalProperties: false,
+      required: Object.keys(fields),
+    }),
+    true,
+    (v) =>
+      Object.fromEntries(
+        Object.entries(v).map(([k, v]) => [k, fields[k]![""].transform(v)]),
+      ) as never,
+  )
 }

package/src/types/primitives.ts

@@ -1,17 +1,17 @@
 import { Ty } from "./Ty.js"
 
-export const none: Ty<null, never> = Ty(() => ({
+export const none: Ty<null, never, false> = Ty(() => ({
   type: "null",
-}))
+}), false)
 
-export const boolean: Ty<boolean, never> = Ty(() => ({
+export const boolean: Ty<boolean, never, false> = Ty(() => ({
   type: "boolean",
-}))
+}), false)
 
-export const number: Ty<number, never> = Ty(() => ({
+export const number: Ty<number, never, false> = Ty(() => ({
   type: "number",
-}))
+}), false)
 
-export const string: Ty<string, never> = Ty(() => ({
+export const string: Ty<string, never, false> = Ty(() => ({
   type: "string",
-}))
+}), false)

package/src/types/std/Date.ts

@@ -0,0 +1,19 @@
+import { object } from "../object.js"
+import { number } from "../primitives.js"
+import { transform } from "../transform.js"
+import type { Ty } from "../Ty.js"
+
+export { Date_ as Date }
+const Date_: Ty<Date, never, true> = transform(
+  object({
+    year: number,
+    month: number`Zero-based (0 for January, 11 for December).`,
+    day: number`Day of the month (1-31). Ensure within available range for the specified month.`,
+    hour: number`Zero-based (0-23)`,
+    minute: number`Zero-based (0-59)`,
+    second: number`Zero-based (0-59)`,
+    millisecond: number`Zero-based (0-999)`,
+  }),
+  ({ year, month, day, hour, minute, second, millisecond }) =>
+    new Date(year, month, day, hour, minute, second, millisecond),
+)

package/src/types/std/Option.ts

@@ -2,10 +2,10 @@ import { none } from "../primitives.js"
 import { taggedUnion } from "../taggedUnion.js"
 import type { Ty } from "../Ty.js"
 
-export function option<S extends Ty>(Some: S): ReturnType<
+export function Option<S extends Ty>(Some: S): ReturnType<
   typeof taggedUnion<{
     Some: S
-    None: Ty<null, never>
+    None: typeof none
   }>
 > {
   return taggedUnion({

package/src/types/std/color.ts

@@ -0,0 +1,27 @@
+import { object } from "../object.js"
+import { number } from "../primitives.js"
+import { transform } from "../transform.js"
+import type { Ty } from "../Ty.js"
+
+export const Rgb: Ty<
+  {
+    r: number
+    g: number
+    b: number
+  },
+  never,
+  true
+> = object({
+  r: number`Between 0 and 255`,
+  g: number`Between 0 and 255`,
+  b: number`Between 0 and 255`,
+})
+
+export const Hex: Ty<string, never, true> = transform(
+  Rgb,
+  ({ r, g, b }) => `${toHex(r)}${toHex(g)}${toHex(b)}"`,
+)
+
+function toHex(value: number): string {
+  return value.toString(16).padStart(2, "0")
+}

package/src/types/std/mod.ts

@@ -1,2 +1,4 @@
+export * from "./color.js"
+export * from "./Date.js"
 export * from "./Option.js"
 export * from "./Wrapper.js"

package/src/types/taggedUnion.ts

@@ -1,4 +1,4 @@
-import { Ty } from "./Ty.js"
+import { type Schema, Ty } from "./Ty.js"
 
 export function taggedUnion<M extends Record<string, Ty>>(members: M): Ty<
   {
@@ -7,21 +7,34 @@ export function taggedUnion<M extends Record<string, Ty>>(members: M): Ty<
       value: M[K]["T"]
     }
   }[keyof M],
-  M[keyof M]["P"]
+  M[keyof M]["P"],
+  false
 > {
-  return Ty((ref) => ({
-    discriminator: "type",
-    anyOf: Object.entries(members).map(([k, v]) => ({
-      type: "object",
-      properties: {
-        type: {
-          type: "string",
-          const: k,
+  const entries = Object.entries(members)
+  return Ty(
+    (subschema) =>
+      entries.length === 1
+        ? variant(entries[0]![0], subschema(entries[0]![1]))
+        : {
+          discriminator: "type",
+          anyOf: entries.map(([k, v]) => variant(k, subschema(v))),
         },
-        value: ref(v),
+    false,
+    (v) => members[v.type]![""].transform(v),
+  )
+}
+
+function variant(type: string, value: Schema) {
+  return {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        const: type,
       },
-      required: ["type", "value"],
-      additionalProperties: false,
-    })),
-  }))
+      value,
+    },
+    required: ["type", "value"],
+    additionalProperties: false,
+  }
 }

package/src/types/transform.ts

@@ -0,0 +1,8 @@
+import { Ty } from "./Ty.js"
+
+export function transform<T, P extends keyof any, R extends boolean, I>(
+  ty: Ty<I, P, R>,
+  transform: (value: I) => T,
+): Ty<T, P, R> {
+  return Ty<T, P, R, I>((ref) => ref(ty), ty[""].root, (value) => transform(value))
+}

package/src/types/tuple.ts

@@ -0,0 +1,17 @@
+import { Ty } from "./Ty.js"
+
+export function tuple<F extends Ty[]>(
+  ...elements: F
+): Ty<{ [K in keyof F]: F[K]["T"] }, F[number]["P"], true> {
+  const { length } = elements
+  return Ty(
+    (ref) => ({
+      type: "object",
+      properties: Object.fromEntries(Array.from({ length }, (_0, i) => [i, ref(elements[i]!)])),
+      additionalProperties: false,
+      required: Object.keys(Array.from({ length }, (_0, i) => i)),
+    }),
+    true,
+    (v) => Array.from({ length }, (_0, i) => elements[i]![""].transform(v[i])) as never,
+  )
+}

package/src/util/recombine.ts

@@ -0,0 +1,3 @@
+export function recombine(strings: TemplateStringsArray, values: Array<number | string>): string {
+  return strings.reduce((acc, cur, i) => `${acc}${cur}${values[i] ?? ""}`, "")
+}

package/esm/oai.d.ts

@@ -1,5 +0,0 @@
-import type Openai from "openai";
-export type JsonSchema = Openai.ResponseFormatJSONSchema["json_schema"];
-export type ChatCompletion = Openai.Chat.ChatCompletion;
-export type ChatCompletionChoice = Openai.Chat.Completions.ChatCompletion.Choice;
-//# sourceMappingURL=oai.d.ts.map

package/esm/oai.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"oai.d.ts","sourceRoot":"","sources":["../src/oai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAEhC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAA;AACvE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAA;AACvD,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,CAAA"}

package/esm/oai.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=oai.js.map

package/esm/oai.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"oai.js","sourceRoot":"","sources":["../src/oai.ts"],"names":[],"mappings":""}

package/esm/types/Ref.d.ts

@@ -1,4 +0,0 @@
-import type { Applied, Schema, Ty } from "./Ty.js";
-export type Ref = (ty: Ty) => Schema;
-export declare function Ref(applied: Applied): Ref;
-//# sourceMappingURL=Ref.d.ts.map

package/esm/types/Ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../src/types/Ref.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAElD,MAAM,MAAM,GAAG,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,MAAM,CAAA;AAEpC,wBAAgB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,GAAG,CAazC"}

package/esm/types/Ref.js

@@ -1,14 +0,0 @@
-import { recombineTaggedTemplateArgs } from "../util/recombineTaggedTemplateArgs.js";
-export function Ref(applied) {
-    return (ty) => {
-        applied = { ...applied, ...ty[""].applied };
-        const description = ty[""].context
-            .map(({ template, placeheld }) => recombineTaggedTemplateArgs(template, placeheld.map((k) => applied[k])))
-            .join(" ");
-        return {
-            ...ty[""].toSchema(Ref(applied)),
-            ...description ? { description } : {},
-        };
-    };
-}
-//# sourceMappingURL=Ref.js.map

package/esm/types/Ref.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Ref.js","sourceRoot":"","sources":["../../src/types/Ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAA;AAKpF,MAAM,UAAU,GAAG,CAAC,OAAgB;IAClC,OAAO,CAAC,EAAE,EAAE,EAAE;QACZ,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,CAAA;QAC3C,MAAM,WAAW,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO;aAC/B,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,EAAE,CAC/B,2BAA2B,CAAC,QAAQ,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAE,CAAC,CAAC,CACzE;aACA,IAAI,CAAC,GAAG,CAAC,CAAA;QACZ,OAAO;YACL,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAChC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE;SACtC,CAAA;IACH,CAAC,CAAA;AACH,CAAC"}

package/esm/types/RootTy.d.ts

@@ -1,8 +0,0 @@
-import type { Applied, Context, Schema, ToSchema, Ty } from "./Ty.js";
-export declare function RootTy<T, P extends keyof any = never>(toSchema: ToSchema, context?: Array<Context>, applied?: Applied): RootTy<T, P>;
-export interface RootTy<T = any, P extends keyof any = keyof any> extends Ty<T, P> {
-    <P2 extends Array<keyof any>>(template: TemplateStringsArray, ...placeheld: P2): RootTy<T, P | P2[number]>;
-    fill: <A extends Partial<Record<P, number | string>>>(values: A) => RootTy<T, Exclude<P, keyof A>>;
-    schema(this: RootTy<T, never>): Schema;
-}
-//# sourceMappingURL=RootTy.d.ts.map

package/esm/types/RootTy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RootTy.d.ts","sourceRoot":"","sources":["../../src/types/RootTy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAErE,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,GAAG,KAAK,EACnD,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,KAAK,CAAC,OAAO,CAAM,EAC5B,OAAO,GAAE,OAAY,GACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAkBd;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,GAAG,MAAM,GAAG,CAAE,SAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAChF,CAAC,EAAE,SAAS,KAAK,CAAC,MAAM,GAAG,CAAC,EAC1B,QAAQ,EAAE,oBAAoB,EAC9B,GAAG,SAAS,EAAE,EAAE,GACf,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;IAC5B,IAAI,EAAE,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAClD,MAAM,EAAE,CAAC,KACN,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAA;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,MAAM,CAAA;CACvC"}

package/esm/types/RootTy.js

@@ -1,17 +0,0 @@
-import { phantoms } from "../util/phantoms.js";
-import { Ref } from "./Ref.js";
-export function RootTy(toSchema, context = [], applied = {}) {
-    return Object.assign((template, ...placeheld) => RootTy(toSchema, [{ template, placeheld }, ...context], applied), phantoms(), {
-        "": { toSchema, context, applied },
-        fill: (values) => {
-            return RootTy(toSchema, context, { ...applied, ...values });
-        },
-        schema() {
-            return Ref({})(this);
-        },
-        isRoot() {
-            return true;
-        },
-    });
-}
-//# sourceMappingURL=RootTy.js.map