lissa 1.0.0 → 1.0.2

package/lib/index.d.ts

@@ -4,39 +4,39 @@ import { RequestInit, HeadersInit, BodyInit, Headers } from 'undici-types';
  * General json typing
  */
 
-type JsonPrimitive = null | string | number | boolean;
+export type JsonPrimitive = null | string | number | boolean;
 
-type JsonObject = {
+export type JsonObject = {
 	[key: string]: Json;
 };
 
-type JsonArray = Json[];
+export type JsonArray = Json[];
 
-type Json = JsonPrimitive | JsonObject | JsonArray;
+export type Json = JsonPrimitive | JsonObject | JsonArray;
 
 /*
  * Param typing (like json but it supports dates if paramsSerializer is set to extended mode)
  */
 
-type ParamPrimitive = null | string | number | bigint | boolean | Date;
+export type ParamPrimitive = null | string | number | bigint | boolean | Date;
 
-type ParamObject = {
+export type ParamObject = {
 	[key: string]: ParamValue;
 };
 
-type ParamArray = ParamValue[];
+export type ParamArray = ParamValue[];
 
-type ParamValue = ParamPrimitive | ParamObject | ParamArray;
+export type ParamValue = ParamPrimitive | ParamObject | ParamArray;
 
-type Params = ParamObject;
+export type Params = ParamObject;
 
 /*
  * Input and output types
  */
 
-type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | (string & {});
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | (string & {});
 
-type LissaOptionsInit = Omit<RequestInit, 'method' | 'body'> & {
+export type LissaOptionsInit = Omit<RequestInit, 'method' | 'body'> & {
 	adapter?: 'fetch' | 'xhr';
 	baseURL?: string;
 	url?: string;
@@ -52,12 +52,12 @@ type LissaOptionsInit = Omit<RequestInit, 'method' | 'body'> & {
 	body?: BodyInit | JsonObject;
 };
 
-type LissaOptions = Omit<LissaOptionsInit, 'headers'> & {
+export type LissaOptions = Omit<LissaOptionsInit, 'headers'> & {
 	headers: Headers
 	params: Params;
 };
 
-type DefaultOptionsInit = LissaOptionsInit & {
+export type DefaultOptionsInit = LissaOptionsInit & {
 	get?: LissaOptionsInit;
 	post?: LissaOptionsInit;
 	put?: LissaOptionsInit;
@@ -65,7 +65,7 @@ type DefaultOptionsInit = LissaOptionsInit & {
 	delete?: LissaOptionsInit;
 };
 
-type DefaultOptions = LissaOptions & {
+export type DefaultOptions = LissaOptions & {
 	get: LissaOptions;
 	post: LissaOptions;
 	put: LissaOptions;
@@ -73,12 +73,12 @@ type DefaultOptions = LissaOptions & {
 	delete: LissaOptions;
 };
 
-type FetchArguments = {
+export type FetchArguments = {
 	url: URL,
 	options: Omit<RequestInit, 'headers'> & { headers: Headers },
 };
 
-type LissaResult = {
+export type LissaResult = {
 	options: LissaOptions;
 	request: FetchArguments;
 	response: Response;
@@ -87,18 +87,18 @@ type LissaResult = {
 	data: null | string | Json | File | ReadableStream | Blob;
 };
 
-type GeneralErrorResponse = Error & {
+export type GeneralErrorResponse = Error & {
 	options: LissaOptions;
 	request: FetchArguments;
 };
 
-type ResultValue = LissaResult | Exclude<any, undefined>;
+export type ResultValue = LissaResult | Exclude<any, undefined>;
 
 /*
  * Interfaces
  */
 
-declare class LissaRequest extends Promise<ResultValue> {
+export declare class LissaRequest extends Promise<ResultValue> {
 	readonly options: LissaOptions;
 
 	/**
@@ -293,9 +293,9 @@ interface MakeRequest {
 	): LissaRequest;
 }
 
-type Plugin = (lissa: Lissa) => void;
+export type Plugin = (lissa: Lissa) => void;
 
-interface Lissa extends MakeRequest {
+export interface Lissa extends MakeRequest {
 	/**
 	 * Modify the base options directly.
 	 *
@@ -417,18 +417,18 @@ export declare class ResponseError extends Error {
  *
  * Retry requests on connection errors or server errors
  */
-export declare const retry: (options: RetryOptions) => Plugin;
+export declare const retry: (options?: RetryOptions) => Plugin;
 
-type CustomRetryError = {
+export type CustomRetryError = {
 	/** custom retry type have to be returned by shouldRetry hook */
 	[K in `on${string}`]: number;
 };
 
-type RetryOptions = CustomRetryError & {
-	onConnectionError: number;
-	onGatewayError: number;
-	on429: number;
-	onServerError: number;
+export type RetryOptions = CustomRetryError & {
+	onConnectionError?: number;
+	onGatewayError?: number;
+	on429?: number;
+	onServerError?: number;
 
 	/**
 	 * Decide if the occurred error should trigger a retry.
@@ -439,38 +439,38 @@ type RetryOptions = CustomRetryError & {
 	 * maximum retries can be configured as `on${errorType}`. Return "CustomError"
 	 * and define the retries as { onCustomError: 3 }
 	 */
-	shouldRetry(
+	shouldRetry?: (
 		errorType: void | 'ConnectionError' | 'GatewayError' | '429' | 'ServerError',
 		error: ResponseError | ConnectionError | GeneralErrorResponse,
-	): void | false | string;
+	) => void | false | string;
 
 	/**
 	 * Hook into the retry logic after the retry is triggered and before the delay
 	 * is awaited. Use beforeRetry e. g. if you want to change how long the delay
 	 * should be or to notify a customer that the connection is lost.
 	 */
-	beforeRetry(
+	beforeRetry?: (
 		retry: { attempt: number, delay: number },
 		error: ResponseError | ConnectionError | GeneralErrorResponse,
-	): void | { attempt: number, delay: number };
+	) => void | { attempt: number, delay: number };
 
 	/**
 	 * Hook into the retry logic after the delay is awaited and before the request
 	 * gets resend. Use onRetry e. g. if you want to log that a retry is running now
 	 */
-	onRetry(
+	onRetry?: (
 		retry: { attempt: number, delay: number },
 		error: ResponseError | ConnectionError | GeneralErrorResponse,
-	): void;
+	) => void;
 
 	/**
 	 * Hook into the retry logic after a request was successful. Use onSuccess
 	 * e. g. if you want to dismiss a connection lost notification
 	 */
-	onSuccess(
+	onSuccess?: (
 		retry: { attempt: number, delay: number },
 		res: ResultValue,
-	): void;
+	) => void;
 };
 
 /**
@@ -478,26 +478,26 @@ type RetryOptions = CustomRetryError & {
  *
  * Aborts leading or trailing requests to the same endpoint (depends on configured strategy [default is leading])
  */
-export declare const dedupe: (options: DedupeOptions) => Plugin;
+export declare const dedupe: (options?: DedupeOptions) => Plugin;
 
-type DedupeOptions = {
+export type DedupeOptions = {
 	/**
 	 * Which request methods should be deduped. Defaults to "get"
 	 */
-	methods: HttpMethod[];
+	methods?: HttpMethod[];
 
 	/**
 	 * How to build the endpoint identifier. Defaults to url + method.
 	 * Return false to skip dedupe logic.
 	 */
-	getIdentifier: (options: LissaOptions) => any;
+	getIdentifier?: (options: LissaOptions) => any;
 
 	/**
 	 * Define default strategy. Abort leading requests on new request or abort
 	 * trailing new requests until first finishes. Can be also configured
 	 * individually by adding a dedupe param to the request options.
 	 */
-	defaultStrategy: 'leading' | 'trailing';
+	defaultStrategy?: 'leading' | 'trailing';
 };
 
 // Named exports are also params of the default export

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lissa",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A lightweight, extensible HTTP client for modern JavaScript applications with fluent api syntax, hooks, plugins and more.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",