@fuman/fetch 0.1.0 → 0.1.2

package/README.md

@@ -1,5 +1,7 @@
 # `@fuman/fetch`
 
+![bundlejs](https://deno.bundlejs.com/badge?q=@fuman/fetch&treeshake=[{+ffetchBase+}])
+
 no-bullshit minimal wrapper around `window.fetch` that aims to improve dx
 by adding commonly used features, while having low runtime overhead,
 small bundle size and staying close to the web standards.
@@ -10,4 +12,4 @@ small bundle size and staying close to the web standards.
 - base url, base headers, etc.
 - retries, timeouts, validation built in
 - basic middlewares
-- **type-safe** compatibility with popular parsing libraries (yup, zod, valibot, etc.)
+- **type-safe** compatibility with popular parsing libraries thanks to [standard-schema](https://github.com/standard-schema/standard-schema)

package/addons/bundle.cjs

@@ -9,6 +9,7 @@ const retry = require("./retry.cjs");
 const timeout = require("./timeout.cjs");
 exports.form = form.form;
 exports.multipart = multipart.multipart;
+exports.SchemaValidationError = addon.SchemaValidationError;
 exports.parser = addon.parser;
 exports.query = query.query;
 exports.rateLimitHandler = rateLimit.rateLimitHandler;

package/addons/bundle.js

@@ -1,12 +1,13 @@
 import { form } from "./form.js";
 import { multipart } from "./multipart.js";
-import { parser } from "./parse/addon.js";
+import { SchemaValidationError, parser } from "./parse/addon.js";
 import { query } from "./query.js";
 import { rateLimitHandler } from "./rate-limit.js";
 import { RetriesExceededError, retry } from "./retry.js";
 import { TimeoutError, timeout } from "./timeout.js";
 export {
   RetriesExceededError,
+  SchemaValidationError,
   TimeoutError,
   form,
   multipart,

package/addons/parse/addon.cjs

@@ -1,15 +1,41 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function parser(parser2) {
+class SchemaValidationError extends Error {
+  constructor(issues) {
+    let message = "Schema validation failed";
+    for (const issue of issues) {
+      message += `: ${issue.message}`;
+      if (issue.path) {
+        const pathStr = [];
+        for (const path of issue.path) {
+          if (typeof path === "object") {
+            pathStr.push(String(path.key));
+          } else {
+            pathStr.push(String(path));
+          }
+        }
+        message += ` at .${pathStr.join(".")}`;
+      }
+    }
+    super(message);
+    this.issues = issues;
+  }
+}
+function parser() {
   return {
     response: {
       async parsedJson(schema) {
-        return parser2.parse(schema, await this.json());
+        const res = await schema["~standard"].validate(await this.json());
+        if (res.issues) {
+          throw new SchemaValidationError(res.issues);
+        }
+        return res.value;
       },
       async safelyParsedJson(schema) {
-        return parser2.safeParse(schema, await this.json());
+        return schema["~standard"].validate(await this.json());
       }
     }
   };
 }
+exports.SchemaValidationError = SchemaValidationError;
 exports.parser = parser;

package/addons/parse/addon.d.cts

@@ -1,7 +1,12 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { FfetchAddon } from '../types.js';
-import { CallSafeTypeProvider, CallTypeProvider, FfetchParser, FfetchTypeProvider } from './_types.js';
-export { FfetchParser, FfetchTypeProvider };
-export declare function parser<TypeProvider extends FfetchTypeProvider>(parser: FfetchParser<TypeProvider>): FfetchAddon<object, {
-    parsedJson: <Schema>(schema: Schema) => Promise<CallTypeProvider<TypeProvider, Schema>>;
-    safelyParsedJson: <Schema>(schema: Schema) => Promise<CallSafeTypeProvider<TypeProvider, Schema>>;
-}>;
+/** Schema validation failed when calling `parsedJson` */
+export declare class SchemaValidationError extends Error {
+    readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+    constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+export interface ParserAddon {
+    parsedJson: <T extends StandardSchemaV1>(schema: T) => Promise<StandardSchemaV1.InferOutput<T>>;
+    safelyParsedJson: <T extends StandardSchemaV1>(schema: T) => Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>>;
+}
+export declare function parser(): FfetchAddon<object, ParserAddon>;

package/addons/parse/addon.d.ts

@@ -1,7 +1,12 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { FfetchAddon } from '../types.js';
-import { CallSafeTypeProvider, CallTypeProvider, FfetchParser, FfetchTypeProvider } from './_types.js';
-export { FfetchParser, FfetchTypeProvider };
-export declare function parser<TypeProvider extends FfetchTypeProvider>(parser: FfetchParser<TypeProvider>): FfetchAddon<object, {
-    parsedJson: <Schema>(schema: Schema) => Promise<CallTypeProvider<TypeProvider, Schema>>;
-    safelyParsedJson: <Schema>(schema: Schema) => Promise<CallSafeTypeProvider<TypeProvider, Schema>>;
-}>;
+/** Schema validation failed when calling `parsedJson` */
+export declare class SchemaValidationError extends Error {
+    readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
+    constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+export interface ParserAddon {
+    parsedJson: <T extends StandardSchemaV1>(schema: T) => Promise<StandardSchemaV1.InferOutput<T>>;
+    safelyParsedJson: <T extends StandardSchemaV1>(schema: T) => Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>>;
+}
+export declare function parser(): FfetchAddon<object, ParserAddon>;

package/addons/parse/addon.js

@@ -1,15 +1,41 @@
-function parser(parser2) {
+class SchemaValidationError extends Error {
+  constructor(issues) {
+    let message = "Schema validation failed";
+    for (const issue of issues) {
+      message += `: ${issue.message}`;
+      if (issue.path) {
+        const pathStr = [];
+        for (const path of issue.path) {
+          if (typeof path === "object") {
+            pathStr.push(String(path.key));
+          } else {
+            pathStr.push(String(path));
+          }
+        }
+        message += ` at .${pathStr.join(".")}`;
+      }
+    }
+    super(message);
+    this.issues = issues;
+  }
+}
+function parser() {
   return {
     response: {
       async parsedJson(schema) {
-        return parser2.parse(schema, await this.json());
+        const res = await schema["~standard"].validate(await this.json());
+        if (res.issues) {
+          throw new SchemaValidationError(res.issues);
+        }
+        return res.value;
       },
       async safelyParsedJson(schema) {
-        return parser2.safeParse(schema, await this.json());
+        return schema["~standard"].validate(await this.json());
       }
     }
   };
 }
 export {
+  SchemaValidationError,
   parser
 };

package/addons/rate-limit.d.cts

@@ -1,5 +1,5 @@
-import { FfetchAddon } from './types.js';
 import { MaybePromise } from '@fuman/utils';
+import { FfetchAddon } from './types.js';
 export interface RateLimitAddon {
     rateLimit?: {
         /**

package/addons/rate-limit.d.ts

@@ -1,5 +1,5 @@
-import { FfetchAddon } from './types.js';
 import { MaybePromise } from '@fuman/utils';
+import { FfetchAddon } from './types.js';
 export interface RateLimitAddon {
     rateLimit?: {
         /**

package/default.cjs

@@ -6,12 +6,14 @@ const query = require("./addons/query.cjs");
 const form = require("./addons/form.cjs");
 const multipart = require("./addons/multipart.cjs");
 const retry = require("./addons/retry.cjs");
+const addon = require("./addons/parse/addon.cjs");
 const ffetchDefaultAddons = [
   /* @__PURE__ */ timeout.timeout(),
   /* @__PURE__ */ query.query(),
   /* @__PURE__ */ form.form(),
   /* @__PURE__ */ multipart.multipart(),
-  /* @__PURE__ */ retry.retry()
+  /* @__PURE__ */ retry.retry(),
+  /* @__PURE__ */ addon.parser()
 ];
 const ffetchBase = /* @__PURE__ */ ffetch.createFfetch({
   addons: ffetchDefaultAddons

package/default.d.cts

@@ -5,7 +5,8 @@ export declare const ffetchDefaultAddons: [
     FfetchAddon<ffetchAddons.QueryAddon, object>,
     FfetchAddon<ffetchAddons.FormAddon, object>,
     FfetchAddon<ffetchAddons.MultipartAddon, object>,
-    FfetchAddon<ffetchAddons.RetryAddon, object>
+    FfetchAddon<ffetchAddons.RetryAddon, object>,
+    FfetchAddon<object, ffetchAddons.ParserAddon>
 ];
 /**
  * the default ffetch instance with a reasonable default set of addons
@@ -28,4 +29,4 @@ export declare const ffetchDefaultAddons: [
  * })
  * ```
  */
-export declare const ffetchBase: Ffetch<ffetchAddons.TimeoutAddon & ffetchAddons.QueryAddon & ffetchAddons.FormAddon & ffetchAddons.MultipartAddon & ffetchAddons.RetryAddon, object>;
+export declare const ffetchBase: Ffetch<ffetchAddons.TimeoutAddon & ffetchAddons.QueryAddon & ffetchAddons.FormAddon & ffetchAddons.MultipartAddon & ffetchAddons.RetryAddon, ffetchAddons.ParserAddon>;

package/default.d.ts

@@ -5,7 +5,8 @@ export declare const ffetchDefaultAddons: [
     FfetchAddon<ffetchAddons.QueryAddon, object>,
     FfetchAddon<ffetchAddons.FormAddon, object>,
     FfetchAddon<ffetchAddons.MultipartAddon, object>,
-    FfetchAddon<ffetchAddons.RetryAddon, object>
+    FfetchAddon<ffetchAddons.RetryAddon, object>,
+    FfetchAddon<object, ffetchAddons.ParserAddon>
 ];
 /**
  * the default ffetch instance with a reasonable default set of addons
@@ -28,4 +29,4 @@ export declare const ffetchDefaultAddons: [
  * })
  * ```
  */
-export declare const ffetchBase: Ffetch<ffetchAddons.TimeoutAddon & ffetchAddons.QueryAddon & ffetchAddons.FormAddon & ffetchAddons.MultipartAddon & ffetchAddons.RetryAddon, object>;
+export declare const ffetchBase: Ffetch<ffetchAddons.TimeoutAddon & ffetchAddons.QueryAddon & ffetchAddons.FormAddon & ffetchAddons.MultipartAddon & ffetchAddons.RetryAddon, ffetchAddons.ParserAddon>;

package/default.js

@@ -4,12 +4,14 @@ import { query } from "./addons/query.js";
 import { form } from "./addons/form.js";
 import { multipart } from "./addons/multipart.js";
 import { retry } from "./addons/retry.js";
+import { parser } from "./addons/parse/addon.js";
 const ffetchDefaultAddons = [
   /* @__PURE__ */ timeout(),
   /* @__PURE__ */ query(),
   /* @__PURE__ */ form(),
   /* @__PURE__ */ multipart(),
-  /* @__PURE__ */ retry()
+  /* @__PURE__ */ retry(),
+  /* @__PURE__ */ parser()
 ];
 const ffetchBase = /* @__PURE__ */ createFfetch({
   addons: ffetchDefaultAddons

package/ffetch.cjs

@@ -66,6 +66,9 @@ class FfetchResultImpl {
         } catch {
         }
       }
+      if (this._options.mapError != null) {
+        throw this._options.mapError(err);
+      }
       throw err;
     }
     return res;
@@ -195,6 +198,8 @@ function createFfetch(baseOptions = {}) {
     }
     init.headers = headers;
     options.validateResponse ??= baseOptions.validateResponse;
+    options.readBodyOnError ??= baseOptions.readBodyOnError;
+    options.mapError ??= baseOptions.mapError;
     return new FfetchResultInner(fetcher, url, init, headers, options, stack);
   };
   const fn = fn_;

package/ffetch.d.cts

@@ -23,6 +23,30 @@ export interface FfetchOptions {
      * @default true
      */
     readBodyOnError?: boolean;
+    /**
+     * optional function to map the error
+     *
+     * useful when your API has an app-level error format, and you want to throw a custom error
+     *
+     * @param err  original {@link HttpError} that would have been thrown
+     * @returns  the error to be thrown instead
+     * @example
+     * ```ts
+     * const api = createFfetch({
+     *   ...,
+     *   mapError: (err) => {
+     *     if (err.response.headers.get('Content-Type') !== 'application/json') return err
+     *     try {
+     *       // note: .bodyText is only available if `readBodyOnError` is true
+     *       const json = JSON.parse(err.bodyText)
+     *       throw new ApiError(json.errorCode, json.message)
+     *     } catch {
+     *       return err
+     *     }
+     *   }
+     * })
+     */
+    mapError?: (err: HttpError) => Error;
     /**
      * base url to be prepended to the url
      *

package/ffetch.d.ts

@@ -23,6 +23,30 @@ export interface FfetchOptions {
      * @default true
      */
     readBodyOnError?: boolean;
+    /**
+     * optional function to map the error
+     *
+     * useful when your API has an app-level error format, and you want to throw a custom error
+     *
+     * @param err  original {@link HttpError} that would have been thrown
+     * @returns  the error to be thrown instead
+     * @example
+     * ```ts
+     * const api = createFfetch({
+     *   ...,
+     *   mapError: (err) => {
+     *     if (err.response.headers.get('Content-Type') !== 'application/json') return err
+     *     try {
+     *       // note: .bodyText is only available if `readBodyOnError` is true
+     *       const json = JSON.parse(err.bodyText)
+     *       throw new ApiError(json.errorCode, json.message)
+     *     } catch {
+     *       return err
+     *     }
+     *   }
+     * })
+     */
+    mapError?: (err: HttpError) => Error;
     /**
      * base url to be prepended to the url
      *

package/ffetch.js

@@ -64,6 +64,9 @@ class FfetchResultImpl {
         } catch {
         }
       }
+      if (this._options.mapError != null) {
+        throw this._options.mapError(err);
+      }
       throw err;
     }
     return res;
@@ -193,6 +196,8 @@ function createFfetch(baseOptions = {}) {
     }
     init.headers = headers;
     options.validateResponse ??= baseOptions.validateResponse;
+    options.readBodyOnError ??= baseOptions.readBodyOnError;
+    options.mapError ??= baseOptions.mapError;
     return new FfetchResultInner(fetcher, url, init, headers, options, stack);
   };
   const fn = fn_;

package/package.json

@@ -1,18 +1,15 @@
 {
     "name": "@fuman/fetch",
     "type": "module",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "description": "tiny wrapper over fetch",
     "license": "MIT",
     "dependencies": {
-        "@fuman/utils": "^0.0.14"
+        "@fuman/utils": "^0.0.16",
+        "@standard-schema/spec": "^1.0.0"
     },
     "peerDependencies": {
-        "@badrap/valita": ">=0.4.0",
-        "tough-cookie": "^5.0.0 || ^4.0.0",
-        "valibot": "^0.42.0",
-        "yup": "^1.0.0",
-        "zod": "^3.0.0"
+        "tough-cookie": "^6.0.0 || ^5.0.0 || ^4.0.0"
     },
     "exports": {
         ".": {
@@ -25,46 +22,6 @@
                 "default": "./index.cjs"
             }
         },
-        "./zod": {
-            "import": {
-                "types": "./zod.d.ts",
-                "default": "./zod.js"
-            },
-            "require": {
-                "types": "./zod.d.cts",
-                "default": "./zod.cjs"
-            }
-        },
-        "./valibot": {
-            "import": {
-                "types": "./valibot.d.ts",
-                "default": "./valibot.js"
-            },
-            "require": {
-                "types": "./valibot.d.cts",
-                "default": "./valibot.cjs"
-            }
-        },
-        "./yup": {
-            "import": {
-                "types": "./yup.d.ts",
-                "default": "./yup.js"
-            },
-            "require": {
-                "types": "./yup.d.cts",
-                "default": "./yup.cjs"
-            }
-        },
-        "./valita": {
-            "import": {
-                "types": "./valita.d.ts",
-                "default": "./valita.js"
-            },
-            "require": {
-                "types": "./valita.d.cts",
-                "default": "./valita.cjs"
-            }
-        },
         "./tough": {
             "import": {
                 "types": "./tough.d.ts",
@@ -78,20 +35,8 @@
     },
     "sideEffects": false,
     "peerDependenciesMeta": {
-        "@badrap/valita": {
-            "optional": true
-        },
         "tough-cookie": {
             "optional": true
-        },
-        "valibot": {
-            "optional": true
-        },
-        "yup": {
-            "optional": true
-        },
-        "zod": {
-            "optional": true
         }
     },
     "author": "",

package/addons/parse/_types.d.cts

@@ -1,16 +0,0 @@
-export interface FfetchTypeProvider {
-    readonly schema: unknown;
-    readonly parsed: unknown;
-    readonly safeParsed: unknown;
-}
-export interface FfetchParser<TypeProvider extends FfetchTypeProvider> {
-    readonly _provider: TypeProvider;
-    parse: (schema: unknown, value: unknown) => unknown | Promise<unknown>;
-    safeParse: (schema: unknown, value: unknown) => unknown | Promise<unknown>;
-}
-export type CallTypeProvider<TypeProvider extends FfetchTypeProvider, Schema> = (TypeProvider & {
-    schema: Schema;
-})['parsed'];
-export type CallSafeTypeProvider<TypeProvider extends FfetchTypeProvider, Schema> = (TypeProvider & {
-    schema: Schema;
-})['safeParsed'];

package/addons/parse/_types.d.ts

@@ -1,16 +0,0 @@
-export interface FfetchTypeProvider {
-    readonly schema: unknown;
-    readonly parsed: unknown;
-    readonly safeParsed: unknown;
-}
-export interface FfetchParser<TypeProvider extends FfetchTypeProvider> {
-    readonly _provider: TypeProvider;
-    parse: (schema: unknown, value: unknown) => unknown | Promise<unknown>;
-    safeParse: (schema: unknown, value: unknown) => unknown | Promise<unknown>;
-}
-export type CallTypeProvider<TypeProvider extends FfetchTypeProvider, Schema> = (TypeProvider & {
-    schema: Schema;
-})['parsed'];
-export type CallSafeTypeProvider<TypeProvider extends FfetchTypeProvider, Schema> = (TypeProvider & {
-    schema: Schema;
-})['safeParsed'];

package/addons/parse/adapters/valibot.d.cts

@@ -1,9 +0,0 @@
-import { BaseIssue, BaseSchema, BaseSchemaAsync, Config, InferOutput, SafeParseResult } from 'valibot';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-export interface ValibotTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>) ? InferOutput<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>) ? SafeParseResult<this['schema']> : never;
-}
-export declare function ffetchValibotAdapter({ async, ...rest }?: Partial<Config<BaseIssue<unknown>>> & {
-    async?: boolean;
-}): FfetchParser<ValibotTypeProvider>;

package/addons/parse/adapters/valibot.d.ts

@@ -1,9 +0,0 @@
-import { BaseIssue, BaseSchema, BaseSchemaAsync, Config, InferOutput, SafeParseResult } from 'valibot';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-export interface ValibotTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>) ? InferOutput<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends (BaseSchema<unknown, unknown, BaseIssue<unknown>> | BaseSchemaAsync<unknown, unknown, BaseIssue<unknown>>) ? SafeParseResult<this['schema']> : never;
-}
-export declare function ffetchValibotAdapter({ async, ...rest }?: Partial<Config<BaseIssue<unknown>>> & {
-    async?: boolean;
-}): FfetchParser<ValibotTypeProvider>;

package/addons/parse/adapters/valita.d.cts

@@ -1,9 +0,0 @@
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-import type * as v from '@badrap/valita';
-export interface ValitaTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends v.Type<any> ? v.Infer<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends v.Type<any> ? v.ValitaResult<v.Infer<this['schema']>> : never;
-}
-type ParseOptions = NonNullable<Parameters<v.Type<any>['parse']>[1]>;
-export declare function ffetchValitaAdapter(options?: ParseOptions): FfetchParser<ValitaTypeProvider>;
-export {};

package/addons/parse/adapters/valita.d.ts

@@ -1,9 +0,0 @@
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-import type * as v from '@badrap/valita';
-export interface ValitaTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends v.Type<any> ? v.Infer<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends v.Type<any> ? v.ValitaResult<v.Infer<this['schema']>> : never;
-}
-type ParseOptions = NonNullable<Parameters<v.Type<any>['parse']>[1]>;
-export declare function ffetchValitaAdapter(options?: ParseOptions): FfetchParser<ValitaTypeProvider>;
-export {};

package/addons/parse/adapters/yup.d.cts

@@ -1,22 +0,0 @@
-import { CastOptions, InferType, ISchema, ValidateOptions, ValidationError } from 'yup';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-type YupSafeParseResult<R> = {
-    success: true;
-    data: R;
-} | {
-    success: false;
-    error: ValidationError;
-};
-export interface YupTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends ISchema<any, any> ? InferType<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends ISchema<any, any> ? YupSafeParseResult<InferType<this['schema']>> : never;
-}
-export type FfetchYupAdapterOptions = {
-    action: 'cast';
-    options?: CastOptions;
-} | {
-    action: 'validate';
-    options?: ValidateOptions;
-};
-export declare function ffetchYupAdapter({ action, options, }?: FfetchYupAdapterOptions): FfetchParser<YupTypeProvider>;
-export {};

package/addons/parse/adapters/yup.d.ts

@@ -1,22 +0,0 @@
-import { CastOptions, InferType, ISchema, ValidateOptions, ValidationError } from 'yup';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-type YupSafeParseResult<R> = {
-    success: true;
-    data: R;
-} | {
-    success: false;
-    error: ValidationError;
-};
-export interface YupTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends ISchema<any, any> ? InferType<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends ISchema<any, any> ? YupSafeParseResult<InferType<this['schema']>> : never;
-}
-export type FfetchYupAdapterOptions = {
-    action: 'cast';
-    options?: CastOptions;
-} | {
-    action: 'validate';
-    options?: ValidateOptions;
-};
-export declare function ffetchYupAdapter({ action, options, }?: FfetchYupAdapterOptions): FfetchParser<YupTypeProvider>;
-export {};

package/addons/parse/adapters/zod.d.cts

@@ -1,7 +0,0 @@
-import { ParseParams, SafeParseReturnType, z } from 'zod';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-export interface ZodTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends z.ZodTypeAny ? z.infer<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends z.ZodTypeAny ? SafeParseReturnType<this['schema'], z.infer<this['schema']>> : never;
-}
-export declare function ffetchZodAdapter({ async, ...rest }?: Partial<ParseParams>): FfetchParser<ZodTypeProvider>;

package/addons/parse/adapters/zod.d.ts

@@ -1,7 +0,0 @@
-import { ParseParams, SafeParseReturnType, z } from 'zod';
-import { FfetchParser, FfetchTypeProvider } from '../_types.js';
-export interface ZodTypeProvider extends FfetchTypeProvider {
-    readonly parsed: this['schema'] extends z.ZodTypeAny ? z.infer<this['schema']> : never;
-    readonly safeParsed: this['schema'] extends z.ZodTypeAny ? SafeParseReturnType<this['schema'], z.infer<this['schema']>> : never;
-}
-export declare function ffetchZodAdapter({ async, ...rest }?: Partial<ParseParams>): FfetchParser<ZodTypeProvider>;

package/valibot.cjs

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const valibot = require("valibot");
-function ffetchValibotAdapter({ async, ...rest } = {}) {
-  const _provider = null;
-  const parser = async ? async function(schema, value) {
-    return valibot.parseAsync(schema, value, rest);
-  } : function(schema, value) {
-    return valibot.parse(schema, value, rest);
-  };
-  const safeParser = async ? async function(schema, value) {
-    return valibot.safeParseAsync(schema, value, rest);
-  } : function(schema, value) {
-    return valibot.safeParse(schema, value, rest);
-  };
-  return {
-    _provider,
-    parse: parser,
-    safeParse: safeParser
-  };
-}
-exports.ffetchValibotAdapter = ffetchValibotAdapter;

package/valibot.d.cts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/valibot.js"

package/valibot.d.ts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/valibot.js"

package/valibot.js

@@ -1,22 +0,0 @@
-import { parseAsync, parse, safeParseAsync, safeParse } from "valibot";
-function ffetchValibotAdapter({ async, ...rest } = {}) {
-  const _provider = null;
-  const parser = async ? async function(schema, value) {
-    return parseAsync(schema, value, rest);
-  } : function(schema, value) {
-    return parse(schema, value, rest);
-  };
-  const safeParser = async ? async function(schema, value) {
-    return safeParseAsync(schema, value, rest);
-  } : function(schema, value) {
-    return safeParse(schema, value, rest);
-  };
-  return {
-    _provider,
-    parse: parser,
-    safeParse: safeParser
-  };
-}
-export {
-  ffetchValibotAdapter
-};

package/valita.cjs

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function ffetchValitaAdapter(options) {
-  const _provider = null;
-  return {
-    _provider,
-    parse(schema, value) {
-      return schema.parse(value, options);
-    },
-    safeParse(schema, value) {
-      return schema.try(value, options);
-    }
-  };
-}
-exports.ffetchValitaAdapter = ffetchValitaAdapter;

package/valita.d.cts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/valita.js"

package/valita.d.ts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/valita.js"

package/valita.js

@@ -1,15 +0,0 @@
-function ffetchValitaAdapter(options) {
-  const _provider = null;
-  return {
-    _provider,
-    parse(schema, value) {
-      return schema.parse(value, options);
-    },
-    safeParse(schema, value) {
-      return schema.try(value, options);
-    }
-  };
-}
-export {
-  ffetchValitaAdapter
-};

package/yup.cjs

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function ffetchYupAdapter({
-  action,
-  options
-} = { action: "validate" }) {
-  const _provider = null;
-  const parse = action === "cast" ? function(schema, value) {
-    return schema.cast(value, options);
-  } : async function(schema, value) {
-    return schema.validate(value, options);
-  };
-  const safeParse = action === "cast" ? function(schema, value) {
-    try {
-      const data = schema.cast(value, options);
-      return { success: true, data };
-    } catch (e) {
-      return { success: false, error: e };
-    }
-  } : async function(schema, value) {
-    try {
-      const data = await schema.validate(value, options);
-      return { success: true, data };
-    } catch (e) {
-      return { success: false, error: e };
-    }
-  };
-  return {
-    _provider,
-    parse,
-    safeParse
-  };
-}
-exports.ffetchYupAdapter = ffetchYupAdapter;

package/yup.d.cts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/yup.js"

package/yup.d.ts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/yup.js"

package/yup.js

@@ -1,34 +0,0 @@
-function ffetchYupAdapter({
-  action,
-  options
-} = { action: "validate" }) {
-  const _provider = null;
-  const parse = action === "cast" ? function(schema, value) {
-    return schema.cast(value, options);
-  } : async function(schema, value) {
-    return schema.validate(value, options);
-  };
-  const safeParse = action === "cast" ? function(schema, value) {
-    try {
-      const data = schema.cast(value, options);
-      return { success: true, data };
-    } catch (e) {
-      return { success: false, error: e };
-    }
-  } : async function(schema, value) {
-    try {
-      const data = await schema.validate(value, options);
-      return { success: true, data };
-    } catch (e) {
-      return { success: false, error: e };
-    }
-  };
-  return {
-    _provider,
-    parse,
-    safeParse
-  };
-}
-export {
-  ffetchYupAdapter
-};

package/zod.cjs

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function ffetchZodAdapter({ async, ...rest } = {}) {
-  const _provider = null;
-  const parse = async ? async function(schema, value) {
-    return schema.parseAsync(value, rest);
-  } : function(schema, value) {
-    return schema.parse(value, rest);
-  };
-  const safeParse = async ? async function(schema, value) {
-    return schema.safeParseAsync(value, rest);
-  } : function(schema, value) {
-    return schema.safeParse(value, rest);
-  };
-  return {
-    _provider,
-    parse,
-    safeParse
-  };
-}
-exports.ffetchZodAdapter = ffetchZodAdapter;

package/zod.d.cts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/zod.js"

package/zod.d.ts

@@ -1 +0,0 @@
-export * from "./addons/parse/adapters/zod.js"

package/zod.js

@@ -1,21 +0,0 @@
-function ffetchZodAdapter({ async, ...rest } = {}) {
-  const _provider = null;
-  const parse = async ? async function(schema, value) {
-    return schema.parseAsync(value, rest);
-  } : function(schema, value) {
-    return schema.parse(value, rest);
-  };
-  const safeParse = async ? async function(schema, value) {
-    return schema.safeParseAsync(value, rest);
-  } : function(schema, value) {
-    return schema.safeParse(value, rest);
-  };
-  return {
-    _provider,
-    parse,
-    safeParse
-  };
-}
-export {
-  ffetchZodAdapter
-};