@tanstack/ai-worldlabs 0.0.0 → 0.1.0

package/src/generated/client/utils.gen.ts

@@ -0,0 +1,332 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { getAuthToken } from '../core/auth.gen'
+import type { QuerySerializerOptions } from '../core/bodySerializer.gen'
+import { jsonBodySerializer } from '../core/bodySerializer.gen'
+import {
+  serializeArrayParam,
+  serializeObjectParam,
+  serializePrimitiveParam,
+} from '../core/pathSerializer.gen'
+import { getUrl } from '../core/utils.gen'
+import type { Client, ClientOptions, Config, RequestOptions } from './types.gen'
+
+export const createQuerySerializer = <T = unknown>({
+  parameters = {},
+  ...args
+}: QuerySerializerOptions = {}): ((queryParams: T) => string) => {
+  const querySerializer = (queryParams: T): string => {
+    const search: string[] = []
+    if (queryParams && typeof queryParams === 'object') {
+      for (const name in queryParams) {
+        const value = queryParams[name]
+
+        if (value === undefined || value === null) {
+          continue
+        }
+
+        const options = parameters[name] || args
+
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: 'form',
+            value,
+            ...options.array,
+          })
+          if (serializedArray) search.push(serializedArray)
+        } else if (typeof value === 'object') {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: 'deepObject',
+            value: value as Record<string, unknown>,
+            ...options.object,
+          })
+          if (serializedObject) search.push(serializedObject)
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value: value as string,
+          })
+          if (serializedPrimitive) search.push(serializedPrimitive)
+        }
+      }
+    }
+    return search.join('&')
+  }
+  return querySerializer
+}
+
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export const getParseAs = (
+  contentType: string | null,
+): Exclude<Config['parseAs'], 'auto'> => {
+  if (!contentType) {
+    // If no Content-Type header is provided, the best we can do is return the raw response body,
+    // which is effectively the same as the 'stream' option.
+    return 'stream'
+  }
+
+  const cleanContent = contentType.split(';')[0]?.trim()
+
+  if (!cleanContent) {
+    return
+  }
+
+  if (
+    cleanContent.startsWith('application/json') ||
+    cleanContent.endsWith('+json')
+  ) {
+    return 'json'
+  }
+
+  if (cleanContent === 'multipart/form-data') {
+    return 'formData'
+  }
+
+  if (
+    ['application/', 'audio/', 'image/', 'video/'].some((type) =>
+      cleanContent.startsWith(type),
+    )
+  ) {
+    return 'blob'
+  }
+
+  if (cleanContent.startsWith('text/')) {
+    return 'text'
+  }
+
+  return
+}
+
+const checkForExistence = (
+  options: Pick<RequestOptions, 'auth' | 'query'> & {
+    headers: Headers
+  },
+  name?: string,
+): boolean => {
+  if (!name) {
+    return false
+  }
+  if (
+    options.headers.has(name) ||
+    options.query?.[name] ||
+    options.headers.get('Cookie')?.includes(`${name}=`)
+  ) {
+    return true
+  }
+  return false
+}
+
+export async function setAuthParams(
+  options: Pick<RequestOptions, 'auth' | 'query' | 'security'> & {
+    headers: Headers
+  },
+): Promise<void> {
+  for (const auth of options.security ?? []) {
+    if (checkForExistence(options, auth.name)) {
+      continue
+    }
+
+    const token = await getAuthToken(auth, options.auth)
+
+    if (!token) {
+      continue
+    }
+
+    const name = auth.name ?? 'Authorization'
+
+    switch (auth.in) {
+      case 'query':
+        if (!options.query) {
+          options.query = {}
+        }
+        options.query[name] = token
+        break
+      case 'cookie':
+        options.headers.append('Cookie', `${name}=${token}`)
+        break
+      case 'header':
+      default:
+        options.headers.set(name, token)
+        break
+    }
+  }
+}
+
+export const buildUrl: Client['buildUrl'] = (options) =>
+  getUrl({
+    baseUrl: options.baseUrl as string,
+    path: options.path,
+    query: options.query,
+    querySerializer:
+      typeof options.querySerializer === 'function'
+        ? options.querySerializer
+        : createQuerySerializer(options.querySerializer),
+    url: options.url,
+  })
+
+export const mergeConfigs = (a: Config, b: Config): Config => {
+  const config = { ...a, ...b }
+  if (config.baseUrl?.endsWith('/')) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1)
+  }
+  config.headers = mergeHeaders(a.headers, b.headers)
+  return config
+}
+
+const headersEntries = (headers: Headers): Array<[string, string]> => {
+  const entries: Array<[string, string]> = []
+  headers.forEach((value, key) => {
+    entries.push([key, value])
+  })
+  return entries
+}
+
+export const mergeHeaders = (
+  ...headers: Array<Required<Config>['headers'] | undefined>
+): Headers => {
+  const mergedHeaders = new Headers()
+  for (const header of headers) {
+    if (!header) {
+      continue
+    }
+
+    const iterator =
+      header instanceof Headers
+        ? headersEntries(header)
+        : Object.entries(header)
+
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key)
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v as string)
+        }
+      } else if (value !== undefined) {
+        // assume object headers are meant to be JSON stringified, i.e., their
+        // content value in OpenAPI specification is 'application/json'
+        mergedHeaders.set(
+          key,
+          typeof value === 'object' ? JSON.stringify(value) : (value as string),
+        )
+      }
+    }
+  }
+  return mergedHeaders
+}
+
+type ErrInterceptor<Err, Res, Req, Options> = (
+  error: Err,
+  /** response may be undefined due to a network error where no response object is produced */
+  response: Res | undefined,
+  /** request may be undefined, because error may be from building the request object itself */
+  request: Req | undefined,
+  options: Options,
+) => Err | Promise<Err>
+
+type ReqInterceptor<Req, Options> = (
+  request: Req,
+  options: Options,
+) => Req | Promise<Req>
+
+type ResInterceptor<Res, Req, Options> = (
+  response: Res,
+  request: Req,
+  options: Options,
+) => Res | Promise<Res>
+
+class Interceptors<Interceptor> {
+  fns: Array<Interceptor | null> = []
+
+  clear(): void {
+    this.fns = []
+  }
+
+  eject(id: number | Interceptor): void {
+    const index = this.getInterceptorIndex(id)
+    if (this.fns[index]) {
+      this.fns[index] = null
+    }
+  }
+
+  exists(id: number | Interceptor): boolean {
+    const index = this.getInterceptorIndex(id)
+    return Boolean(this.fns[index])
+  }
+
+  getInterceptorIndex(id: number | Interceptor): number {
+    if (typeof id === 'number') {
+      return this.fns[id] ? id : -1
+    }
+    return this.fns.indexOf(id)
+  }
+
+  update(
+    id: number | Interceptor,
+    fn: Interceptor,
+  ): number | Interceptor | false {
+    const index = this.getInterceptorIndex(id)
+    if (this.fns[index]) {
+      this.fns[index] = fn
+      return id
+    }
+    return false
+  }
+
+  use(fn: Interceptor): number {
+    this.fns.push(fn)
+    return this.fns.length - 1
+  }
+}
+
+export interface Middleware<Req, Res, Err, Options> {
+  error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>
+  request: Interceptors<ReqInterceptor<Req, Options>>
+  response: Interceptors<ResInterceptor<Res, Req, Options>>
+}
+
+export const createInterceptors = <Req, Res, Err, Options>(): Middleware<
+  Req,
+  Res,
+  Err,
+  Options
+> => ({
+  error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
+  request: new Interceptors<ReqInterceptor<Req, Options>>(),
+  response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
+})
+
+const defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: 'form',
+  },
+  object: {
+    explode: true,
+    style: 'deepObject',
+  },
+})
+
+const defaultHeaders = {
+  'Content-Type': 'application/json',
+}
+
+export const createConfig = <T extends ClientOptions = ClientOptions>(
+  override: Config<Omit<ClientOptions, keyof T> & T> = {},
+): Config<Omit<ClientOptions, keyof T> & T> => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: 'auto',
+  querySerializer: defaultQuerySerializer,
+  ...override,
+})

package/src/generated/client.gen.ts

@@ -0,0 +1,26 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import {
+  type Client,
+  type ClientOptions,
+  type Config,
+  createClient,
+  createConfig,
+} from './client'
+import type { ClientOptions as ClientOptions2 } from './types.gen'
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
+  override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>
+
+export const client: Client = createClient(
+  createConfig<ClientOptions2>({ baseUrl: 'https://api.worldlabs.ai' }),
+)

package/src/generated/client.ts

@@ -0,0 +1,3 @@
+// Barrel so `from './client'` in generated files emits `./client.js`
+// (scan-dangling-dts). Keep this file if you regenerate the Hey API client.
+export * from './client/index'

package/src/generated/core/auth.gen.ts

@@ -0,0 +1,48 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined
+
+export interface Auth {
+  /**
+   * Which part of the request do we use to send the auth?
+   *
+   * @default 'header'
+   */
+  in?: 'header' | 'query' | 'cookie'
+  /**
+   * A unique identifier for the security scheme.
+   *
+   * Defined only when there are multiple security schemes whose `Auth`
+   * shape would otherwise be identical.
+   */
+  key?: string
+  /**
+   * Header or query parameter name.
+   *
+   * @default 'Authorization'
+   */
+  name?: string
+  scheme?: 'basic' | 'bearer'
+  type: 'apiKey' | 'http'
+}
+
+export const getAuthToken = async (
+  auth: Auth,
+  callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+  const token = typeof callback === 'function' ? await callback(auth) : callback
+
+  if (!token) {
+    return
+  }
+
+  if (auth.scheme === 'bearer') {
+    return `Bearer ${token}`
+  }
+
+  if (auth.scheme === 'basic') {
+    return `Basic ${btoa(token)}`
+  }
+
+  return token
+}

package/src/generated/core/bodySerializer.gen.ts

@@ -0,0 +1,96 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type {
+  ArrayStyle,
+  ObjectStyle,
+  SerializerOptions,
+} from './pathSerializer.gen'
+
+export type QuerySerializer = (query: Record<string, unknown>) => string
+
+export type BodySerializer = (body: unknown) => unknown
+
+type QuerySerializerOptionsObject = {
+  allowReserved?: boolean
+  array?: Partial<SerializerOptions<ArrayStyle>>
+  object?: Partial<SerializerOptions<ObjectStyle>>
+}
+
+export type QuerySerializerOptions = QuerySerializerOptionsObject & {
+  /**
+   * Per-parameter serialization overrides. When provided, these settings
+   * override the global array/object settings for specific parameter names.
+   */
+  parameters?: Record<string, QuerySerializerOptionsObject>
+}
+
+const serializeFormDataPair = (
+  data: FormData,
+  key: string,
+  value: unknown,
+): void => {
+  if (typeof value === 'string' || value instanceof Blob) {
+    data.append(key, value)
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString())
+  } else {
+    data.append(key, JSON.stringify(value))
+  }
+}
+
+const serializeUrlSearchParamsPair = (
+  data: URLSearchParams,
+  key: string,
+  value: unknown,
+): void => {
+  if (typeof value === 'string') {
+    data.append(key, value)
+  } else {
+    data.append(key, JSON.stringify(value))
+  }
+}
+
+export const formDataBodySerializer = {
+  bodySerializer: (body: unknown): FormData => {
+    const data = new FormData()
+
+    Object.entries(body as Record<string, unknown>).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v))
+      } else {
+        serializeFormDataPair(data, key, value)
+      }
+    })
+
+    return data
+  },
+}
+
+export const jsonBodySerializer = {
+  bodySerializer: (body: unknown): string =>
+    JSON.stringify(body, (_key, value) =>
+      typeof value === 'bigint' ? value.toString() : value,
+    ),
+}
+
+export const urlSearchParamsBodySerializer = {
+  bodySerializer: (body: unknown): string => {
+    const data = new URLSearchParams()
+
+    Object.entries(body as Record<string, unknown>).forEach(([key, value]) => {
+      if (value === undefined || value === null) {
+        return
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeUrlSearchParamsPair(data, key, v))
+      } else {
+        serializeUrlSearchParamsPair(data, key, value)
+      }
+    })
+
+    return data.toString()
+  },
+}

package/src/generated/core/params.gen.ts

@@ -0,0 +1,186 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = 'body' | 'headers' | 'path' | 'query'
+
+export type Field =
+  | {
+      in: Exclude<Slot, 'body'>
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If omitted, we use the same value as `key`.
+       */
+      map?: string
+    }
+  | {
+      in: Extract<Slot, 'body'>
+      /**
+       * Key isn't required for bodies.
+       */
+      key?: string
+      map?: string
+    }
+  | {
+      /**
+       * Field name. This is the name we want the user to see and use.
+       */
+      key: string
+      /**
+       * Field mapped name. This is the name we want to use in the request.
+       * If `in` is omitted, `map` aliases `key` to the transport layer.
+       */
+      map: Slot
+    }
+
+export interface Fields {
+  allowExtra?: Partial<Record<Slot, boolean>>
+  args?: ReadonlyArray<Field>
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>
+
+const extraPrefixesMap: Record<string, Slot> = {
+  $body_: 'body',
+  $headers_: 'headers',
+  $path_: 'path',
+  $query_: 'query',
+}
+const extraPrefixes = Object.entries(extraPrefixesMap)
+
+type KeyMap = Map<
+  string,
+  | {
+      in: Slot
+      map?: string
+    }
+  | {
+      in?: never
+      map: Slot
+    }
+>
+
+function buildKeyMap(fields: FieldsConfig, map?: KeyMap): KeyMap {
+  if (!map) {
+    map = new Map()
+  }
+
+  for (const config of fields) {
+    if ('in' in config) {
+      if (config.key) {
+        map.set(config.key, {
+          in: config.in,
+          map: config.map,
+        })
+      }
+    } else if ('key' in config) {
+      map.set(config.key, {
+        map: config.map,
+      })
+    } else if (config.args) {
+      buildKeyMap(config.args, map)
+    }
+  }
+
+  return map
+}
+
+interface Params {
+  body?: unknown
+  headers: Record<string, unknown>
+  path: Record<string, unknown>
+  query: Record<string, unknown>
+}
+
+function stripEmptySlots(params: Params): void {
+  for (const [slot, value] of Object.entries(params)) {
+    if (slot === 'body') continue
+    if (
+      value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      !Object.keys(value).length
+    ) {
+      delete params[slot as Slot]
+    }
+  }
+}
+
+export function buildClientParams(
+  args: ReadonlyArray<unknown>,
+  fields: FieldsConfig,
+): Params {
+  const params: Params = {
+    headers: Object.create(null),
+    path: Object.create(null),
+    query: Object.create(null),
+  }
+
+  const map = buildKeyMap(fields)
+
+  function writeSlot(slot: Slot, key: string, value: unknown): void {
+    let record = params[slot] as Record<string, unknown> | undefined
+    if (record === undefined) {
+      record = Object.create(null) as Record<string, unknown>
+      params[slot] = record
+    }
+    record[key] = value
+  }
+
+  let config: FieldsConfig[number] | undefined
+
+  for (const [index, arg] of args.entries()) {
+    if (fields[index]) {
+      config = fields[index]
+    }
+
+    if (!config) {
+      continue
+    }
+
+    if ('in' in config) {
+      if (config.key) {
+        const field = map.get(config.key)!
+        const name = field.map || config.key
+        if (field.in) {
+          writeSlot(field.in, name, arg)
+        }
+      } else {
+        params.body = arg
+      }
+    } else {
+      for (const [key, value] of Object.entries(arg ?? {})) {
+        const field = map.get(key)
+
+        if (field) {
+          if (field.in) {
+            const name = field.map || key
+            writeSlot(field.in, name, value)
+          } else {
+            params[field.map] = value
+          }
+        } else {
+          const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix))
+
+          if (extra) {
+            const [prefix, slot] = extra
+            writeSlot(slot, key.slice(prefix.length), value)
+          } else if ('allowExtra' in config && config.allowExtra) {
+            for (const [slot, allowed] of Object.entries(config.allowExtra)) {
+              if (allowed) {
+                writeSlot(slot as Slot, key, value)
+                break
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  stripEmptySlots(params)
+
+  return params
+}