bluera-knowledge 0.14.0 → 0.14.1

package/tests/fixtures/corpus/oss-repos/hono/src/client/types.ts

@@ -1,182 +0,0 @@
-import type { Hono } from '../hono'
-import type { Endpoint, ResponseFormat, Schema } from '../types'
-import type { StatusCode, SuccessStatusCode } from '../utils/http-status'
-import type { HasRequiredKeys } from '../utils/types'
-
-type HonoRequest = (typeof Hono.prototype)['request']
-
-export type ClientRequestOptions<T = unknown> = {
-  fetch?: typeof fetch | HonoRequest
-  webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket
-  /**
-   * Standard `RequestInit`, caution that this take highest priority
-   * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
-   *
-   * If you want to add some headers, use in `headers` instead of `init`
-   */
-  init?: RequestInit
-} & (keyof T extends never
-  ? {
-      headers?:
-        | Record<string, string>
-        | (() => Record<string, string> | Promise<Record<string, string>>)
-    }
-  : {
-      headers: T | (() => T | Promise<T>)
-    })
-
-export type ClientRequest<S extends Schema> = {
-  [M in keyof S]: S[M] extends Endpoint & { input: infer R }
-    ? R extends object
-      ? HasRequiredKeys<R> extends true
-        ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<S[M]>>
-        : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<S[M]>>
-      : never
-    : never
-} & {
-  $url: (
-    arg?: S[keyof S] extends { input: infer R }
-      ? R extends { param: infer P }
-        ? { param: P }
-        : {}
-      : {}
-  ) => URL
-} & (S['$get'] extends { outputFormat: 'ws' }
-    ? S['$get'] extends { input: infer I }
-      ? {
-          $ws: (args?: I) => WebSocket
-        }
-      : {}
-    : {})
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type BlankRecordToNever<T> = T extends any
-  ? T extends null
-    ? null
-    : keyof T extends never
-      ? never
-      : T
-  : never
-
-type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
-  output: infer O
-  outputFormat: infer F
-  status: infer S
-}
-  ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never>
-  : never
-
-export interface ClientResponse<
-  T,
-  U extends number = StatusCode,
-  F extends ResponseFormat = ResponseFormat,
->
-  extends globalThis.Response {
-  readonly body: ReadableStream | null
-  readonly bodyUsed: boolean
-  ok: U extends SuccessStatusCode
-    ? true
-    : U extends Exclude<StatusCode, SuccessStatusCode>
-      ? false
-      : boolean
-  status: U
-  statusText: string
-  headers: Headers
-  url: string
-  redirect(url: string, status: number): Response
-  clone(): Response
-  json(): F extends 'text'
-    ? Promise<never>
-    : F extends 'json'
-      ? Promise<BlankRecordToNever<T>>
-      : Promise<unknown>
-  text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>
-  blob(): Promise<Blob>
-  formData(): Promise<FormData>
-  arrayBuffer(): Promise<ArrayBuffer>
-}
-
-export interface Response extends ClientResponse<unknown> {}
-
-export type Fetch<T> = (
-  args?: InferRequestType<T>,
-  opt?: ClientRequestOptions
-) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>
-
-type InferEndpointType<T> = T extends (
-  args: infer R,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  options: any | undefined
-) => Promise<infer U>
-  ? U extends ClientResponse<infer O, infer S, infer F>
-    ? { input: NonNullable<R>; output: O; outputFormat: F; status: S } extends Endpoint
-      ? { input: NonNullable<R>; output: O; outputFormat: F; status: S }
-      : never
-    : never
-  : never
-
-export type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<
-  InferEndpointType<T>,
-  U
->
-
-type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
-  output: infer O
-  status: infer S
-}
-  ? S extends U
-    ? O
-    : never
-  : never
-
-export type InferRequestType<T> = T extends (
-  args: infer R,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  options: any | undefined
-) => Promise<ClientResponse<unknown>>
-  ? NonNullable<R>
-  : never
-
-export type InferRequestOptionsType<T> = T extends (
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  args: any,
-  options: infer R
-) => Promise<ClientResponse<unknown>>
-  ? NonNullable<R>
-  : never
-
-type PathToChain<
-  Path extends string,
-  E extends Schema,
-  Original extends string = Path,
-> = Path extends `/${infer P}`
-  ? PathToChain<P, E, Path>
-  : Path extends `${infer P}/${infer R}`
-    ? { [K in P]: PathToChain<R, E, Original> }
-    : {
-        [K in Path extends '' ? 'index' : Path]: ClientRequest<
-          E extends Record<string, unknown> ? E[Original] : never
-        >
-      }
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Client<T> =
-  T extends Hono<any, infer S, any>
-    ? S extends Record<infer K, Schema>
-      ? K extends string
-        ? PathToChain<K, S>
-        : never
-      : never
-    : never
-
-export type Callback = (opts: CallbackOptions) => unknown
-
-interface CallbackOptions {
-  path: string[]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  args: any[]
-}
-
-export type ObjectType<T = unknown> = {
-  [key: string]: T
-}

package/tests/fixtures/corpus/oss-repos/hono/src/client/utils.ts

@@ -1,54 +0,0 @@
-import type { ObjectType } from './types'
-
-export const mergePath = (base: string, path: string) => {
-  base = base.replace(/\/+$/, '')
-  base = base + '/'
-  path = path.replace(/^\/+/, '')
-  return base + path
-}
-
-export const replaceUrlParam = (urlString: string, params: Record<string, string | undefined>) => {
-  for (const [k, v] of Object.entries(params)) {
-    const reg = new RegExp('/:' + k + '(?:{[^/]+})?\\??')
-    urlString = urlString.replace(reg, v ? `/${v}` : '')
-  }
-  return urlString
-}
-
-export const replaceUrlProtocol = (urlString: string, protocol: 'ws' | 'http') => {
-  switch (protocol) {
-    case 'ws':
-      return urlString.replace(/^http/, 'ws')
-    case 'http':
-      return urlString.replace(/^ws/, 'http')
-  }
-}
-
-export const removeIndexString = (urlSting: string) => {
-  if (/^https?:\/\/[^\/]+?\/index$/.test(urlSting)) {
-    return urlSting.replace(/\/index$/, '/')
-  }
-  return urlSting.replace(/\/index$/, '')
-}
-
-function isObject(item: unknown): item is ObjectType {
-  return typeof item === 'object' && item !== null && !Array.isArray(item)
-}
-
-export function deepMerge<T>(target: T, source: Record<string, unknown>): T {
-  if (!isObject(target) && !isObject(source)) {
-    return source as T
-  }
-  const merged = { ...target } as ObjectType<T>
-
-  for (const key in source) {
-    const value = source[key]
-    if (isObject(merged[key]) && isObject(value)) {
-      merged[key] = deepMerge(merged[key], value)
-    } else {
-      merged[key] = value as T[keyof T] & T
-    }
-  }
-
-  return merged as T
-}

package/tests/fixtures/corpus/oss-repos/hono/src/compose.ts

@@ -1,94 +0,0 @@
-import { Context } from './context'
-import type { ParamIndexMap, Params } from './router'
-import type { Env, ErrorHandler, NotFoundHandler } from './types'
-
-/**
- * Interface representing the context for a composition operation.
- */
-interface ComposeContext {
-  /**
-   * Indicates whether the composition process has been finalized.
-   */
-  finalized: boolean
-
-  /**
-   * The result of the composition process. The type is unknown and should be
-   * specified based on the context where this interface is used.
-   */
-  res: unknown
-}
-
-/**
- * Compose middleware functions into a single function based on `koa-compose` package.
- *
- * @template C - The context type.
- * @template E - The environment type.
- *
- * @param {[[Function, unknown], ParamIndexMap | Params][]} middleware - An array of middleware functions and their corresponding parameters.
- * @param {ErrorHandler<E>} [onError] - An optional error handler function.
- * @param {NotFoundHandler<E>} [onNotFound] - An optional not-found handler function.
- *
- * @returns {(context: C, next?: Function) => Promise<C>} - A composed middleware function.
- */
-export const compose = <C extends ComposeContext, E extends Env = Env>(
-  middleware: [[Function, unknown], ParamIndexMap | Params][],
-  onError?: ErrorHandler<E>,
-  onNotFound?: NotFoundHandler<E>
-): ((context: C, next?: Function) => Promise<C>) => {
-  return (context, next) => {
-    let index = -1
-    return dispatch(0)
-
-    /**
-     * Dispatch the middleware functions.
-     *
-     * @param {number} i - The current index in the middleware array.
-     *
-     * @returns {Promise<C>} - A promise that resolves to the context.
-     */
-    async function dispatch(i: number): Promise<C> {
-      if (i <= index) {
-        throw new Error('next() called multiple times')
-      }
-      index = i
-
-      let res
-      let isError = false
-      let handler
-
-      if (middleware[i]) {
-        handler = middleware[i][0][0]
-        if (context instanceof Context) {
-          context.req.routeIndex = i
-        }
-      } else {
-        handler = (i === middleware.length && next) || undefined
-      }
-
-      if (!handler) {
-        if (context instanceof Context && context.finalized === false && onNotFound) {
-          res = await onNotFound(context)
-        }
-      } else {
-        try {
-          res = await handler(context, () => {
-            return dispatch(i + 1)
-          })
-        } catch (err) {
-          if (err instanceof Error && context instanceof Context && onError) {
-            context.error = err
-            res = await onError(err, context)
-            isError = true
-          } else {
-            throw err
-          }
-        }
-      }
-
-      if (res && (context.finalized === false || isError)) {
-        context.res = res
-      }
-      return context
-    }
-  }
-}