@intrig/react 0.0.1 → 0.0.2

package/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from './intrig-provider';
-export * from './network-state';

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>>;
-    configs: DefaultConfigs;
-    execute: <T>(request: RequestType, dispatch: (state: NetworkState<T>) => void, schema: ZodSchema<T> | 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,100 +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> {
-    key: string;
-    operation: string;
-    source: string;
-    schema?: ZodSchema<T>;
-    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>({ key, operation, source, schema, debounceDelay: requestDebounceDelay, }: NetworkStateProps<T>): [
-    NetworkState<T>,
-    (request: RequestType) => void,
-    clear: () => void,
-    (state: NetworkState<T>) => 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 useCentralErrorHandling(): {
-    source: string;
-    operation: string;
-    key: string;
-    state: "error";
-    error: any;
-    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 useCentralPendingStateHandling(): NetworkState<unknown>;

package/src/network-state.d.ts

@@ -1,223 +0,0 @@
-/**
- * State of an asynchronous call. Network state follows the state diagram given below.
- *
- *
- * <pre>
- *                 ┌──────┐
- *   ┌─────────────► Init ◄────────────┐
- *   │             └▲────┬┘            │
- *   │              │    │             │
- *   │           Reset  Execute        │
- * Reset            │    │           Reset
- *   │           ┌──┴────┴──┐          │
- *   │      ┌────► Pending  ◄────┐     │
- *   │      │    └──┬────┬──┘    │     │
- *   │   Execute    │    │    Execute  │
- *   │      │       │    │       │     │
- *   │      │ OnSuccess OnError  │     │
- *   │ ┌────┴──┐    │    │    ┌──┴───┐ │
- *   └─┤Success◄────┘    └────►Error ├─┘
- *     └───────┘              └──────┘
- *
- * </pre>
- */
-export interface NetworkState<T = unknown> {
-    state: 'init' | 'pending' | 'success' | 'error';
-}
-/**
- * Network call is not yet started
- */
-export interface InitState<T> extends NetworkState<T> {
-    state: 'init';
-}
-/**
- * Checks whether the state is init state
- * @param state
- */
-export declare function isInit<T>(state: NetworkState<T>): state is InitState<T>;
-/**
- * Initializes a new state.
- *
- * @template T The type of the state.
- * @return {InitState<T>} An object representing the initial state.
- */
-export declare function init<T>(): InitState<T>;
-/**
- * Network call is not yet completed
- */
-export interface PendingState<T> extends NetworkState<T> {
-    state: 'pending';
-    progress?: Progress;
-}
-/**
- * Interface representing progress information for an upload or download operation.
- *
- * @typedef {object} Progress
- *
- * @property {'upload' | 'download'} type - The type of the operation.
- *
- * @property {number} loaded - The amount of data that has been loaded so far.
- *
- * @property {number} [total] - The total amount of data to be loaded (if known).
- */
-export interface Progress {
-    type?: 'upload' | 'download';
-    loaded: number;
-    total?: number;
-}
-/**
- * Checks whether the state is pending state
- * @param state
- */
-export declare function isPending<T>(state: NetworkState<T>): state is PendingState<T>;
-/**
- * Generates a PendingState object with a state of "pending".
- *
- * @return {PendingState<T>} An object representing the pending state.
- */
-export declare function pending<T>(progress?: Progress | undefined): PendingState<T>;
-/**
- * Network call is completed with success state
- */
-export interface SuccessState<T> extends NetworkState<T> {
-    state: 'success';
-    data: T;
-}
-/**
- * Checks whether the state is success response
- * @param state
- */
-export declare function isSuccess<T>(state: NetworkState<T>): state is SuccessState<T>;
-/**
- * Creates a success state object with the provided data.
- *
- * @param {T} data - The data to be included in the success state.
- * @return {SuccessState<T>} An object representing a success state containing the provided data.
- */
-export declare function success<T>(data: T): SuccessState<T>;
-/**
- * Network call is completed with error response
- */
-export interface ErrorState<T> extends NetworkState<T> {
-    state: 'error';
-    error: any;
-    statusCode?: number;
-    request?: any;
-}
-/**
- * Checks whether the state is error state
- * @param state
- */
-export declare function isError<T>(state: NetworkState<T>): state is ErrorState<T>;
-/**
- * Constructs an ErrorState object representing an error.
- *
- * @param {any} error - The error object or message.
- * @param {string} [statusCode] - An optional status code associated with the error.
- * @return {ErrorState<T>} An object representing the error state.
- */
-export declare function error<T>(error: any, statusCode?: number, request?: any): ErrorState<T>;
-/**
- * Represents an error state with additional contextual information.
- *
- * @typedef {Object} ErrorWithContext
- * @template T
- * @extends ErrorState<T>
- *
- * @property {string} source - The origin of the error.
- * @property {string} operation - The operation being performed when the error occurred.
- * @property {string} key - A unique key identifying the specific error instance.
- */
-export interface ErrorWithContext<T = unknown> extends ErrorState<T> {
-    source: string;
-    operation: string;
-    key: string;
-}
-/**
- * Represents an action in the network context.
- *
- * @template T - The type of data associated with the network action
- *
- * @property {NetworkState<any>} state - The current state of the network action
- * @property {string} key - The unique identifier for the network action
- */
-export interface NetworkAction<T> {
-    key: string;
-    source: string;
-    operation: string;
-    state: NetworkState<T>;
-    handled?: boolean;
-}
-type HookWithKey = {
-    key: string;
-};
-export type DeleteHook<P> = ((key?: string) => [NetworkState<never>, (params: P) => void, () => void]) & HookWithKey;
-export type DeleteHookOp<P> = ((key?: string) => [NetworkState<never>, (params?: P) => void, () => void]) & HookWithKey;
-export type GetHook<P, T> = ((key?: string) => [NetworkState<T>, (params: P) => void, () => void]) & HookWithKey;
-export type GetHookOp<P, T> = ((key?: string) => [NetworkState<T>, (params?: P) => void, () => void]) & HookWithKey;
-export type PostHook<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params: P) => void, () => void]) & HookWithKey;
-export type PostHookOp<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params?: P) => void, () => void]) & HookWithKey;
-export type PutHook<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params: P) => void, () => void]) & HookWithKey;
-export type PutHookOp<P, T, B> = ((key?: string) => [NetworkState<T>, (body: B, params?: P) => void, () => void]) & HookWithKey;
-export type IntrigHook<P = undefined, B = undefined, T = any> = DeleteHook<P> | GetHook<P, T> | PostHook<P, T, B> | PutHook<P, T, B> | PostHookOp<P, T, B> | PutHookOp<P, T, B> | GetHookOp<P, T> | DeleteHookOp<P>;
-/**
- * Represents the dispatch state of a process.
- *
- * @template T The type of the state information.
- * @interface
- *
- * @property {string} state The current state of the dispatch process.
- */
-export interface DispatchState<T> {
-    state: string;
-}
-/**
- * Represents a successful dispatch state.
- *
- * @template T - Type of the data associated with the dispatch.
- *
- * @extends DispatchState<T>
- *
- * @property {string} state - The state of the dispatch, always 'success'.
- */
-export interface SuccessfulDispatch<T> extends DispatchState<T> {
-    state: 'success';
-}
-/**
- * Indicates a successful dispatch state.
- *
- * @return {DispatchState<T>} An object representing a successful state.
- */
-export declare function successfulDispatch<T>(): DispatchState<T>;
-/**
- * Determines if the provided dispatch state represents a successful dispatch.
- *
- * @param {DispatchState<T>} value - The dispatch state to check.
- * @return {value is SuccessfulDispatch<T>} - True if the dispatch state indicates success, false otherwise.
- */
-export declare function isSuccessfulDispatch<T>(value: DispatchState<T>): value is SuccessfulDispatch<T>;
-/**
- * ValidationError interface represents a specific type of dispatch state
- * where a validation error has occurred.
- *
- * @typeparam T - The type of the data associated with this dispatch state.
- */
-export interface ValidationError<T> extends DispatchState<T> {
-    state: 'validation-error';
-    error: any;
-}
-/**
- * Generates a ValidationError object.
- *
- * @param error The error details that caused the validation to fail.
- * @return The ValidationError object containing the error state and details.
- */
-export declare function validationError<T>(error: any): ValidationError<T>;
-/**
- * Determines if a provided DispatchState object is a ValidationError.
- *
- * @param {DispatchState<T>} value - The DispatchState object to evaluate.
- * @return {boolean} - Returns true if the provided DispatchState object is a ValidationError, otherwise returns false.
- */
-export declare function isValidationError<T>(value: DispatchState<T>): value is ValidationError<T>;
-export {};