@fuman/fetch 0.0.8 → 0.0.11

package/addons/parse/_types.d.cts

@@ -1,11 +1,16 @@
 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,11 +1,16 @@
 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,7 +1,8 @@
-import { BaseIssue, BaseSchema, BaseSchemaAsync, Config, InferOutput } from 'valibot';
+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;

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

@@ -1,7 +1,8 @@
-import { BaseIssue, BaseSchema, BaseSchemaAsync, Config, InferOutput } from 'valibot';
+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;

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

@@ -2,6 +2,7 @@ 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>;

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

@@ -2,6 +2,7 @@ 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>;

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

@@ -1,7 +1,15 @@
-import { CastOptions, InferType, ISchema, ValidateOptions } from 'yup';
+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';
@@ -11,3 +19,4 @@ export type FfetchYupAdapterOptions = {
     options?: ValidateOptions;
 };
 export declare function ffetchYupAdapter({ action, options, }?: FfetchYupAdapterOptions): FfetchParser<YupTypeProvider>;
+export {};

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

@@ -1,7 +1,15 @@
-import { CastOptions, InferType, ISchema, ValidateOptions } from 'yup';
+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';
@@ -11,3 +19,4 @@ export type FfetchYupAdapterOptions = {
     options?: ValidateOptions;
 };
 export declare function ffetchYupAdapter({ action, options, }?: FfetchYupAdapterOptions): FfetchParser<YupTypeProvider>;
+export {};

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

@@ -1,6 +1,7 @@
-import { ParseParams, z } from 'zod';
+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,6 +1,7 @@
-import { ParseParams, z } from 'zod';
+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/addon.cjs

@@ -5,6 +5,9 @@ function parser(parser2) {
     response: {
       async parsedJson(schema) {
         return parser2.parse(schema, await this.json());
+      },
+      async safelyParsedJson(schema) {
+        return parser2.safeParse(schema, await this.json());
       }
     }
   };

package/addons/parse/addon.d.cts

@@ -1,6 +1,7 @@
 import { FfetchAddon } from '../types.js';
-import { CallTypeProvider, FfetchParser, FfetchTypeProvider } 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>>;
 }>;

package/addons/parse/addon.d.ts

@@ -1,6 +1,7 @@
 import { FfetchAddon } from '../types.js';
-import { CallTypeProvider, FfetchParser, FfetchTypeProvider } 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>>;
 }>;

package/addons/parse/addon.js

@@ -3,6 +3,9 @@ function parser(parser2) {
     response: {
       async parsedJson(schema) {
         return parser2.parse(schema, await this.json());
+      },
+      async safelyParsedJson(schema) {
+        return parser2.safeParse(schema, await this.json());
       }
     }
   };

package/ffetch.cjs

@@ -108,6 +108,9 @@ ${stack}`;
     const res = await this.raw();
     return res.arrayBuffer();
   }
+  async bytes() {
+    return new Uint8Array(await this.arrayBuffer());
+  }
   async blob() {
     this._headers ??= {};
     this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;

package/ffetch.d.cts

@@ -96,7 +96,7 @@ export interface Ffetch<RequestMixin, ResponseMixin> {
     extend: <const Addons extends FfetchAddon<any, any>[], Combined extends {
         request: object;
         response: object;
-    } = CombineAddons<Addons>>(baseOptions: FfetchBaseOptions<Addons> & Combined['request']) => Ffetch<RequestMixin & Combined['request'], ResponseMixin & Combined['response']>;
+    } = CombineAddons<Addons>>(baseOptions: FfetchBaseOptions<Addons> & RequestMixin & Combined['request']) => Ffetch<RequestMixin & Combined['request'], ResponseMixin & Combined['response']>;
 }
 /**
  * an error that is thrown when the response status is not 2xx,

package/ffetch.d.ts

@@ -96,7 +96,7 @@ export interface Ffetch<RequestMixin, ResponseMixin> {
     extend: <const Addons extends FfetchAddon<any, any>[], Combined extends {
         request: object;
         response: object;
-    } = CombineAddons<Addons>>(baseOptions: FfetchBaseOptions<Addons> & Combined['request']) => Ffetch<RequestMixin & Combined['request'], ResponseMixin & Combined['response']>;
+    } = CombineAddons<Addons>>(baseOptions: FfetchBaseOptions<Addons> & RequestMixin & Combined['request']) => Ffetch<RequestMixin & Combined['request'], ResponseMixin & Combined['response']>;
 }
 /**
  * an error that is thrown when the response status is not 2xx,

package/ffetch.js

@@ -106,6 +106,9 @@ ${stack}`;
     const res = await this.raw();
     return res.arrayBuffer();
   }
+  async bytes() {
+    return new Uint8Array(await this.arrayBuffer());
+  }
   async blob() {
     this._headers ??= {};
     this._headers.Accept ??= OCTET_STREAM_CONTENT_TYPE;

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@fuman/fetch",
     "type": "module",
-    "version": "0.0.8",
+    "version": "0.0.11",
     "description": "tiny wrapper over fetch",
     "license": "MIT",
     "dependencies": {
-        "@fuman/utils": "^0.0.4"
+        "@fuman/utils": "^0.0.11"
     },
     "peerDependencies": {
         "@badrap/valita": ">=0.4.0",

package/valibot.cjs

@@ -8,9 +8,15 @@ function ffetchValibotAdapter({ async, ...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
+    parse: parser,
+    safeParse: safeParser
   };
 }
 exports.ffetchValibotAdapter = ffetchValibotAdapter;

package/valibot.js

@@ -1,4 +1,4 @@
-import { parseAsync, parse } from "valibot";
+import { parseAsync, parse, safeParseAsync, safeParse } from "valibot";
 function ffetchValibotAdapter({ async, ...rest } = {}) {
   const _provider = null;
   const parser = async ? async function(schema, value) {
@@ -6,9 +6,15 @@ function ffetchValibotAdapter({ async, ...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
+    parse: parser,
+    safeParse: safeParser
   };
 }
 export {

package/valita.cjs

@@ -6,6 +6,9 @@ function ffetchValitaAdapter(options) {
     _provider,
     parse(schema, value) {
       return schema.parse(value, options);
+    },
+    safeParse(schema, value) {
+      return schema.try(value, options);
     }
   };
 }

package/valita.js

@@ -4,6 +4,9 @@ function ffetchValitaAdapter(options) {
     _provider,
     parse(schema, value) {
       return schema.parse(value, options);
+    },
+    safeParse(schema, value) {
+      return schema.try(value, options);
     }
   };
 }

package/yup.cjs

@@ -5,14 +5,30 @@ function ffetchYupAdapter({
   options
 } = { action: "validate" }) {
   const _provider = null;
-  const parse = action === "cast" ? async function(schema, value) {
+  const parse = action === "cast" ? function(schema, value) {
     return schema.cast(value, options);
-  } : function(schema, value) {
+  } : 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
+    parse,
+    safeParse
   };
 }
 exports.ffetchYupAdapter = ffetchYupAdapter;

package/yup.js

@@ -3,14 +3,30 @@ function ffetchYupAdapter({
   options
 } = { action: "validate" }) {
   const _provider = null;
-  const parse = action === "cast" ? async function(schema, value) {
+  const parse = action === "cast" ? function(schema, value) {
     return schema.cast(value, options);
-  } : function(schema, value) {
+  } : 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
+    parse,
+    safeParse
   };
 }
 export {

package/zod.cjs

@@ -7,9 +7,15 @@ function ffetchZodAdapter({ async, ...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
+    parse,
+    safeParse
   };
 }
 exports.ffetchZodAdapter = ffetchZodAdapter;

package/zod.js

@@ -5,9 +5,15 @@ function ffetchZodAdapter({ async, ...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
+    parse,
+    safeParse
   };
 }
 export {