@intrig/react 1.0.6 → 1.0.10

package/src/extra/useAsNetworkState.d.ts

@@ -1,13 +0,0 @@
-import { NetworkState } from '@intrig/react/network-state';
-/**
- * A custom hook that integrates a promise-based operation with a network state management system.
- * Tracks the network state (e.g., pending, success, error) for a given asynchronous function.
- *
- * @param fn A promise-based function that performs an asynchronous operation.
- * @param key An optional string key to identify the network state uniquely. Defaults to 'default'.
- * @return A tuple containing:
- *         1. The current network state of the operation.
- *         2. A function to execute the provided asynchronous operation.
- *         3. A function to reset the network state back to the initial state.
- */
-export declare function useAsNetworkState<T, F extends ((...args: any) => Promise<T>)>(fn: F, key?: string): [NetworkState<T>, (...params: Parameters<F>) => void, () => void];

package/src/intrig-context.d.ts

@@ -1,43 +0,0 @@
-import { NetworkAction, NetworkState } from '@intrig/react/network-state';
-import { AxiosProgressEvent } from 'axios';
-import { ZodSchema } from 'zod';
-import { DefaultConfigs } from '@intrig/react/intrig-provider';
-type GlobalState = Record<string, NetworkState>;
-interface RequestType<T = any> {
-    method: 'get' | 'post' | 'put' | 'delete';
-    url: string;
-    headers?: Record<string, string>;
-    params?: Record<string, any>;
-    data?: any;
-    originalData?: T;
-    onUploadProgress?: (event: AxiosProgressEvent) => void;
-    onDownloadProgress?: (event: AxiosProgressEvent) => void;
-    signal?: AbortSignal;
-    key: string;
-    source: string;
-}
-/**
- * Defines the ContextType interface for managing global state, dispatching actions,
- * and holding a collection of Axios instances.
- *
- * @interface ContextType
- * @property {GlobalState} state - The global state of the application.
- * @property {React.Dispatch<NetworkAction<unknown>>} dispatch - The dispatch function to send network actions.
- * @property {Record<string, AxiosInstance>} axios - A record of Axios instances for making HTTP requests.
- */
-export interface ContextType {
-    state: GlobalState;
-    filteredState: GlobalState;
-    dispatch: React.Dispatch<NetworkAction<unknown, unknown>>;
-    configs: DefaultConfigs;
-    execute: <T, E = unknown>(request: RequestType, dispatch: (state: NetworkState<T, E>) => void, schema: ZodSchema<T> | undefined, errorSchema: ZodSchema<E> | undefined) => Promise<void>;
-}
-/**
- * Context object created using `createContext` function. Provides a way to share state, dispatch functions,
- * and axios instance across components without having to pass props down manually at every level.
- *
- * @type {ContextType}
- */
-declare let Context: import("react").Context<ContextType>;
-export declare function useIntrigContext(): ContextType;
-export { Context, GlobalState, RequestType, };

package/src/intrig-provider.d.ts

@@ -1,101 +0,0 @@
-import { PropsWithChildren } from 'react';
-import { IntrigHook, NetworkState } from './network-state';
-import { CreateAxiosDefaults } from 'axios';
-import { ZodSchema } from 'zod';
-import { RequestType } from './intrig-context';
-export interface DefaultConfigs extends CreateAxiosDefaults {
-    debounceDelay?: number;
-}
-export interface IntrigProviderProps {
-    configs?: Record<string, DefaultConfigs>;
-    children: React.ReactNode;
-}
-/**
- * IntrigProvider is a context provider component that sets up global state management
- * and provides Axios instances for API requests.
- *
- * @param {Object} props - The properties object.
- * @param {React.ReactNode} props.children - The child components to be wrapped by the provider.
- * @param {Object} [props.configs={}] - Configuration object for Axios instances.
- * @param {Object} [props.configs.defaults={}] - Default configuration for Axios.
- * @param {Object} [props.configs.petstore={}] - Configuration specific to the petstore API.
- * @return {JSX.Element} A context provider component that wraps the provided children.
- */
-export declare function IntrigProvider({ children, configs, }: IntrigProviderProps): import("react/jsx-runtime").JSX.Element;
-export interface StubType<P, B, T> {
-    <P, B, T>(hook: IntrigHook<P, B, T>, fn: (params: P, body: B, dispatch: (state: NetworkState<T>) => void) => Promise<void>): void;
-}
-export type WithStubSupport<T> = T & {
-    stubs?: (stub: StubType<any, any, any>) => void;
-};
-export interface IntrigProviderStubProps {
-    configs?: DefaultConfigs;
-    stubs?: (stub: StubType<any, any, any>) => void;
-    children: React.ReactNode;
-}
-export declare function IntrigProviderStub({ children, configs, stubs }: IntrigProviderStubProps): import("react/jsx-runtime").JSX.Element;
-export interface StatusTrapProps {
-    type: 'pending' | 'error' | 'pending + error';
-    propagate?: boolean;
-}
-/**
- * StatusTrap component is used to track and manage network request states.
- *
- * @param {Object} props - The properties object.
- * @param {React.ReactNode} props.children - The child elements to be rendered.
- * @param {string} props.type - The type of network state to handle ("error", "pending", "pending + error").
- * @param {boolean} [props.propagate=true] - Whether to propagate the event to the parent context.
- * @return {React.ReactElement} The context provider component with filtered state and custom dispatch.
- */
-export declare function StatusTrap({ children, type, propagate, }: PropsWithChildren<StatusTrapProps>): import("react/jsx-runtime").JSX.Element;
-export interface NetworkStateProps<T, E = unknown> {
-    key: string;
-    operation: string;
-    source: string;
-    schema?: ZodSchema<T>;
-    errorSchema?: ZodSchema<E>;
-    debounceDelay?: number;
-}
-/**
- * useNetworkState is a custom hook that manages the network state within the specified context.
- * It handles making network requests, dispatching appropriate states based on the request lifecycle,
- * and allows aborting ongoing requests.
- *
- * @param {Object} params - The parameters required to configure and use the network state.
- * @param {string} params.key - A unique identifier for the network request.
- * @param {string} params.operation - The operation type related to the request.
- * @param {string} params.source - The source or endpoint for the network request.
- * @param {Object} params.schema - The schema used for validating the response data.
- * @param {number} [params.debounceDelay] - The debounce delay for executing the network request.
- *
- * @return {[NetworkState<T>, (request: AxiosRequestConfig) => void, () => void]}
- *          Returns a state object representing the current network state,
- *          a function to execute the network request, and a function to clear the request.
- */
-export declare function useNetworkState<T, E = unknown>({ key, operation, source, schema, errorSchema, debounceDelay: requestDebounceDelay, }: NetworkStateProps<T>): [
-    NetworkState<T, E>,
-    (request: RequestType) => void,
-    clear: () => void,
-    (state: NetworkState<T, E>) => void
-];
-/**
- * Handles central error extraction from the provided context.
- * It filters the state to retain error states and maps them to a structured error object with additional context information.
- * @return {Object[]} An array of objects representing the error states with context information such as source, operation, and key.
- */
-export declare function useCentralError(): {
-    source: string;
-    operation: string;
-    key: string;
-    state: "error";
-    error: unknown;
-    statusCode?: number;
-    request?: any;
-}[];
-/**
- * Uses central pending state handling by aggregating pending states from context.
- * It calculates the overall progress of pending states if any, or returns an initial state otherwise.
- *
- * @return {NetworkState} The aggregated network state based on the pending states and their progress.
- */
-export declare function useCentralPendingState(): NetworkState<unknown, unknown>;

package/src/media-type-utils.d.ts

@@ -1,3 +0,0 @@
-import { ZodSchema } from 'zod';
-export declare function transform<T>(request: Request, mediaType: string, schema: ZodSchema): Promise<T>;
-export declare function transformResponse<T>(data: any, mediaType: string, schema: ZodSchema): Promise<T>;