acrylblends 1.0.5 → 1.0.6

package/plugins/acryl-router/src/core/app-base.d.ts

@@ -1,215 +0,0 @@
-/**
- * @module
- * This module is the base module for the Acryl object.
- */
-import { Context } from './context.ts';
-import type { ExecutionContext } from './context.ts';
-import type { Router } from './router.ts';
-import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types.ts';
-type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
-}) => string;
-export type AcrylOptions<E extends Env> = {
-    /**
-     * `router` option specifies which router to use.
-     *
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl({ router: new RegExpRouter() })
-     * ```
-     */
-    router?: Router<[H, RouterRoute]>;
-} & ({
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     *
-     *
-     * @default true
-     */
-    strict?: true;
-    /**
-     * `getPath` can handle the host header value.
-     *
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl({
-     *  getPath: (req) =>
-     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
-     * })
-     *
-     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
-     *
-     * // A following request will match the route:
-     * // new Request('http://www1.example.com/hello', {
-     * //  headers: { host: 'www1.example.com' },
-     * // })
-     * ```
-     */
-    getPath?: GetPath<E>;
-} | {
-    /**
-     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
-     * When `strict` is `false`, `getPath` is not used.
-     *
-     *
-     * @default true
-     */
-    strict: false;
-    getPath?: never;
-});
-type MountOptionHandler = (c: Context) => unknown;
-type MountReplaceRequest = (originalRequest: Request) => Request;
-type MountOptions = MountOptionHandler | {
-    optionHandler?: MountOptionHandler;
-    replaceRequest?: MountReplaceRequest | false;
-};
-declare class Acryl<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
-    #private;
-    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
-    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
-    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
-    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
-    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
-    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
-    on: OnHandlerInterface<E, S, BasePath>;
-    use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
-    readonly getPath: GetPath<E>;
-    private _basePath;
-    routes: RouterRoute[];
-    constructor(options?: AcrylOptions<E>);
-    private errorHandler;
-    /**
-     * `.route()` allows grouping other Acryl instance in routes.
-     *
-     *
-     * @param {string} path - base Path
-     * @param {Acryl} app - other Acryl instance
-     * @returns {Acryl} routed Acryl instance
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl()
-     * const app2 = new Acryl()
-     *
-     * app2.get("/user", (c) => c.text("user"))
-     * app.route("/api", app2) // GET /api/user
-     * ```
-     */
-    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Acryl<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Acryl<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
-    /**
-     * `.basePath()` allows base paths to be specified.
-     *
-     *
-     * @param {string} path - base Path
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * const api = new Acryl().basePath('/api')
-     * ```
-     */
-    basePath<SubPath extends string>(path: SubPath): Acryl<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
-    /**
-     * `.onError()` handles an error and returns a customized Response.
-     *
-     *
-     * @param {ErrorHandler} handler - request Handler for error
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * app.onError((err, c) => {
-     *   console.error(`${err}`)
-     *   return c.text('Custom Error Message', 500)
-     * })
-     * ```
-     */
-    onError: (handler: ErrorHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.notFound()` allows you to customize a Not Found Response.
-     *
-     *
-     * @param {NotFoundHandler} handler - request handler for not-found
-     * @returns {Acryl} changed Acryl instance
-     *
-     * @example
-     * ```ts
-     * app.notFound((c) => {
-     *   return c.text('Custom 404 Message', 404)
-     * })
-     * ```
-     */
-    notFound: (handler: NotFoundHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.mount()` allows you to mount applications built with other frameworks into your Acryl application.
-     *
-     * @deprecated Use `mount()` from `acryl-router/mount` instead. `.mount()` will be removed in v5.
-     *
-     *
-     * @param {string} path - base Path
-     * @param {Function} applicationHandler - other Request Handler
-     * @param {MountOptions} [options] - options of `.mount()`
-     * @returns {Acryl} mounted Acryl instance
-     *
-     * @example
-     * ```ts
-     * import { Router as IttyRouter } from 'itty-router'
-     * import { Acryl } from 'acrylblends'
-     * // Create itty-router application
-     * const ittyRouter = IttyRouter()
-     * // GET /itty-router/hello
-     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-     *
-     * const app = new Acryl()
-     * app.mount('/itty-router', ittyRouter.handle)
-     * ```
-     *
-     * @example
-     * ```ts
-     * const app = new Acryl()
-     * // Send the request to another application without modification.
-     * app.mount('/app', anotherApp, {
-     *   replaceRequest: (req) => req,
-     * })
-     * ```
-     */
-    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Acryl<E, S, BasePath, CurrentPath>;
-    /**
-     * `.fetch()` will be entry point of your app.
-     *
-     *
-     * @param {Request} request - request Object of request
-     * @param {Env} env - env Object
-     * @param {ExecutionContext} executionCtx - context of execution
-     * @returns {Response | Promise<Response>} response of request
-     *
-     */
-    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.request()` is a useful method for testing.
-     * You can pass a URL or pathname to send a GET request.
-     * app will return a Response object.
-     * ```ts
-     * test('GET /hello is ok', async () => {
-     *   const res = await app.request('/hello')
-     *   expect(res.status).toBe(200)
-     * })
-     * ```
-     */
-    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    /**
-     * `.fire()` automatically adds a global fetch event listener.
-     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-     * @deprecated
-     * ACRYL ships no service-worker adapter: mount the app with `ctx.router.route(path, app)` and serve it through an ACRYL adapter instead.
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-     */
-    fire: () => void;
-}
-export { Acryl as AcrylBase };

package/plugins/acryl-router/src/core/app.d.ts

@@ -1,19 +0,0 @@
-import { AcrylBase } from './app-base.ts';
-import type { AcrylOptions } from './app-base.ts';
-import type { BlankEnv, BlankSchema, Env, Schema } from './types.ts';
-/**
- * The Acryl class extends the functionality of the AcrylBase class.
- * It sets up routing and allows for custom options to be passed.
- *
- * @template E - The environment type.
- * @template S - The schema type.
- * @template BasePath - The base path type.
- */
-export declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends AcrylBase<E, S, BasePath> {
-    /**
-     * Creates an instance of the Acryl class.
-     *
-     * @param options - Optional configuration options for the Acryl instance.
-     */
-    constructor(options?: AcrylOptions<E>);
-}

package/plugins/acryl-router/src/core/client/client.d.ts

@@ -1,4 +0,0 @@
-import type { Acryl } from '../app.ts';
-import type { UnionToIntersection } from '../utils/types.ts';
-import type { Client, ClientRequestOptions } from './types.ts';
-export declare const hc: <T extends Acryl<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;

package/plugins/acryl-router/src/core/client/fetch-result-please.d.ts

@@ -1,35 +0,0 @@
-/**
- * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
- *
- * @link https://www.npmjs.com/package/fetch-result-please
- */
-/**
- * Smartly parses and return the consumable result from a fetch `Response`.
- *
- * Throwing a structured error if the response is not `ok`. ({@link DetailedError})
- */
-export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
-export declare class DetailedError extends Error {
-    /**
-     * Additional `message` that will be logged AND returned to client
-     */
-    detail?: any;
-    /**
-     * Additional `code` that will be logged AND returned to client
-     */
-    code?: any;
-    /**
-     * Additional value that will be logged AND NOT returned to client
-     */
-    log?: any;
-    /**
-     * Optionally set the status code to return, in a web server context
-     */
-    statusCode?: any;
-    constructor(message: string, options?: {
-        detail?: any;
-        code?: any;
-        statusCode?: number;
-        log?: any;
-    });
-}

package/plugins/acryl-router/src/core/client/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * @module
- * The HTTP Client for Acryl.
- */
-export { hc } from './client.ts';
-export { parseResponse, DetailedError } from './utils.ts';
-export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types.ts';

package/plugins/acryl-router/src/core/client/types.d.ts

@@ -1,229 +0,0 @@
-import type { Acryl } from '../app.ts';
-import type { AcrylBase } from '../app-base.ts';
-import type { METHODS, METHOD_NAME_ALL_LOWERCASE } from '../router.ts';
-import type { Endpoint, ExtractSchema, KnownResponseFormat, ResponseFormat, Schema } from '../types.ts';
-import type { StatusCode, SuccessStatusCode } from '../utils/http-status.ts';
-import type { HasRequiredKeys } from '../utils/types.ts';
-/**
- * Type representing the '$all' method name
- */
-type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
-/**
- * Type representing all standard HTTP methods prefixed with '$'
- * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch' | '$query'
- */
-type StandardMethods = `$${(typeof METHODS)[number]}`;
-/**
- * Expands '$all' into all standard HTTP methods.
- * If the schema contains '$all', it creates a type where all standard HTTP methods
- * point to the same endpoint definition as '$all', while removing '$all' itself.
- */
-type ExpandAllMethod<S> = MethodNameAll extends keyof S ? {
-    [M in StandardMethods]: S[MethodNameAll];
-} & Omit<S, MethodNameAll> : S;
-type AcrylRequest = (typeof Acryl.prototype)['request'];
-export type BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
-export type ClientRequestOptions<T = unknown> = {
-    fetch?: typeof fetch | AcrylRequest;
-    webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
-    /**
-     * Standard `RequestInit`, caution that this take highest priority
-     * and could be used to overwrite things that Acryl sets for you, like `body | method | headers`.
-     *
-     * If you want to add some headers, use in `headers` instead of `init`
-     */
-    init?: RequestInit;
-    /**
-     * Custom function to serialize query parameters into URLSearchParams.
-     * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
-     * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
-     *
-     * @example
-     * ```ts
-     * const client = hc('http://localhost', {
-     *   buildSearchParams: (query) => {
-     *     return new URLSearchParams(qs.stringify(query))
-     *   }
-     * })
-     * ```
-     */
-    buildSearchParams?: BuildSearchParamsFn;
-} & (keyof T extends never ? {
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-} : {
-    headers: T | (() => T | Promise<T>);
-});
-export type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = {
-    [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
-        input: infer R;
-    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never;
-} & {
-    $url: <const Arg extends (S[keyof S] extends {
-        input: infer R;
-    } ? R extends {
-        param: infer P;
-    } ? R extends {
-        query: infer Q;
-    } ? {
-        param: P;
-        query: Q;
-    } : {
-        param: P;
-    } : R extends {
-        query: infer Q;
-    } ? {
-        query: Q;
-    } : {} : {}) | undefined = undefined>(arg?: Arg) => AcrylURL<Prefix, Path, Arg>;
-    $path: <const Arg extends (S[keyof S] extends {
-        input: infer R;
-    } ? R extends {
-        param: infer P;
-    } ? R extends {
-        query: infer Q;
-    } ? {
-        param: P;
-        query: Q;
-    } : {
-        param: P;
-    } : R extends {
-        query: infer Q;
-    } ? {
-        query: Q;
-    } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
-} & (S['$get'] extends {
-    outputFormat: 'ws';
-} ? S['$get'] extends {
-    input: infer I;
-} ? {
-    $ws: (args?: I) => WebSocket;
-} : {} : {});
-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> {
-    readonly body: ReadableStream | null;
-    readonly bodyUsed: boolean;
-    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
-    redirected: boolean;
-    status: U;
-    statusText: string;
-    type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
-    headers: Headers;
-    url: string;
-    redirect(url: string, status: number): Response;
-    clone(): Response;
-    bytes(): Promise<Uint8Array<ArrayBuffer>>;
-    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<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>;
-}
-type BuildSearch<Arg, Key extends 'query'> = Arg extends {
-    [K in Key]: infer Query;
-} ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
-type BuildPathname<P extends string, Arg> = Arg extends {
-    param: infer Param;
-} ? `${ApplyParam<TrimStartSlash<P>, Param>}` : `/${TrimStartSlash<P>}`;
-type BuildPath<P extends string, Arg> = `${BuildPathname<P, Arg>}${BuildSearch<Arg, 'query'>}`;
-type BuildTypedURL<Protocol extends string, Host extends string, Port extends string, P extends string, Arg> = TypedURL<`${Protocol}:`, Host, Port, BuildPathname<P, Arg>, BuildSearch<Arg, 'query'>>;
-type AcrylURL<Prefix extends string, Path extends string, Arg> = IsLiteral<Prefix> extends true ? TrimEndSlash<Prefix> extends `${infer Protocol}://${infer Rest}` ? Rest extends `${infer Hostname}/${infer P}` ? ParseHostName<Hostname> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, P, Arg> : never : ParseHostName<Rest> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, Path, Arg> : never : URL : URL;
-type ParseHostName<T extends string> = T extends `${infer Host}:${infer Port}` ? [Host, Port] : [T, ''];
-type TrimStartSlash<T extends string> = T extends `/${infer R}` ? TrimStartSlash<R> : T;
-type TrimEndSlash<T extends string> = T extends `${infer R}/` ? TrimEndSlash<R> : T;
-type IsLiteral<T extends string> = [T] extends [never] ? false : string extends T ? false : true;
-type ApplyParam<Path extends string, P, Result extends string = ''> = Path extends `${infer Head}/${infer Rest}` ? Head extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? ApplyParam<Rest, P, `${Result}/${Value & string}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : Path extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? `${Result}/${Value & string}` : `${Result}/${Path}` : `${Result}/${Path}` : `${Result}/${Path}`;
-type IsEmptyObject<T> = keyof T extends never ? true : false;
-export interface TypedURL<Protocol extends string, Hostname extends string, Port extends string, Pathname extends string, Search extends string> extends URL {
-    protocol: Protocol;
-    hostname: Hostname;
-    port: Port;
-    host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
-    origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
-    pathname: Pathname;
-    search: Search;
-    href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
-}
-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, 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, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-/**
- * Filter a ClientResponse type so it only includes responses of specific status codes.
- */
-export type FilterClientResponseByStatusCode<T extends ClientResponse<any, any, any>, U extends number = StatusCode> = T extends ClientResponse<infer RT, infer RC, infer RF> ? RC extends U ? ClientResponse<RT, RC, RF> : never : never;
-type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? {
-    [K in P]: PathToChain<Prefix, R, E, Original>;
-} : {
-    [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never>;
-};
-export type Client<T, Prefix extends string> = T extends AcrylBase<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
-export type Callback = (opts: CallbackOptions) => unknown;
-interface CallbackOptions {
-    path: string[];
-    args: any[];
-}
-export type ObjectType<T = unknown> = {
-    [key: string]: T;
-};
-type GlobalResponseDefinition = {
-    [S in StatusCode]?: {
-        [F in KnownResponseFormat]?: unknown;
-    };
-};
-type ToEndpoints<Def extends GlobalResponseDefinition, R> = {
-    [S in keyof Def & StatusCode]: {
-        [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
-            output: Def[S][F];
-            status: S;
-            outputFormat: F;
-        };
-    }[keyof Def[S] & KnownResponseFormat];
-}[keyof Def & StatusCode];
-type ModRoute<R, Def extends GlobalResponseDefinition> = R extends Endpoint ? R | ToEndpoints<Def, R> : R;
-type ModSchema<D, Def extends GlobalResponseDefinition> = {
-    [K in keyof D]: {
-        [M in keyof D[K]]: ModRoute<D[K][M], Def>;
-    };
-};
-export type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends AcrylBase<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends infer S extends Schema ? Acryl<E, S, B> : never : never;
-type PickRoute<R, U extends StatusCode> = R extends Endpoint ? R extends {
-    status: U;
-} ? R : never : R;
-type PickSchema<D, U extends StatusCode> = {
-    [K in keyof D]: {
-        [M in keyof D[K]]: PickRoute<D[K][M], U>;
-    };
-};
-/**
- * Keep only specific status code responses from all routes of an app.
- * Useful when error responses are handled centrally (e.g., via custom fetch)
- * and you want the client to only expose success response types.
- *
- * @example
- * ```ts
- * type AppSuccessOnly = PickResponseByStatusCode<typeof app, 200>
- * const client = hc<AppSuccessOnly>('http://localhost')
- * ```
- */
-export type PickResponseByStatusCode<App, U extends StatusCode> = App extends AcrylBase<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends infer S extends Schema ? Acryl<E, S, B> : never : never;
-export {};

package/plugins/acryl-router/src/core/client/utils.d.ts

@@ -1,18 +0,0 @@
-import type { ClientErrorStatusCode, ContentfulStatusCode, ServerErrorStatusCode } from '../utils/http-status.ts';
-import { DetailedError } from './fetch-result-please.ts';
-import type { ClientResponse, FilterClientResponseByStatusCode } from './types.ts';
-export { DetailedError };
-export declare const mergePath: (base: string, path: string) => string;
-export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
-export declare const buildSearchParams: (query: Record<string, string | string[]>) => URLSearchParams;
-export declare const replaceUrlProtocol: (urlString: string, protocol: "ws" | "http") => string;
-export declare const removeIndexString: (urlString: string) => string;
-export declare function deepMerge<T>(target: T, source: Record<string, unknown>): T;
-/**
- * Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
- *
- * Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
- *
- * @example const result = await parseResponse(client.posts.$get())
- */
-export declare function parseResponse<T extends ClientResponse<any>>(fetchRes: T | Promise<T>): Promise<FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends never ? undefined : FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends ClientResponse<infer RT, infer _, infer RF> ? RF extends 'json' ? RT : RT extends string ? RT : string : undefined>;

package/plugins/acryl-router/src/core/compose.d.ts

@@ -1,14 +0,0 @@
-import type { Context } from './context.ts';
-import type { Env, ErrorHandler, Next, NotFoundHandler } from './types.ts';
-/**
- * Compose middleware functions into a single function based on `koa-compose` package.
- *
- * @template E - The environment type.
- *
- * @param {[[Function, unknown], unknown][] | [[Function]][]} 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: Context, next?: Next) => Promise<Context>} - A composed middleware function.
- */
-export declare const compose: <E extends Env = Env>(middleware: [[Function, unknown], unknown][] | [[Function]][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: Context, next?: Next) => Promise<Context>);