@intrig/react 1.0.6 → 1.0.10

package/.babelrc

@@ -0,0 +1,12 @@
+{
+  "presets": [
+    [
+      "@nx/react/babel",
+      {
+        "runtime": "automatic",
+        "useBuiltIns": "usage"
+      }
+    ]
+  ],
+  "plugins": []
+}

package/README.md

@@ -1,33 +1,35 @@
-# Intrig
+# @intrig/react
 
-Intrig is a powerful tool for simplifying API integration in React applications. It provides enhanced documentation, API version management, and developer tooling for seamless frontend-backend integration.
+@intrig/react is a placeholder project for code generation, specifically tailored for React projects. This package is part of the Intrig toolset, designed to streamline the development process by providing autogenerated code and utilities for React applications.
 
-## Getting Started
-
-Prerequisites
+## Features
 
-* Node.js v16+.
-* Nx build tool.
+- **Code Generation for React Projects**: Generate boilerplate code to kickstart React development quickly and efficiently.
+- **Easy Integration**: Works seamlessly with React to create scalable and maintainable applications.
 
-## Installation
+## Getting Started
 
-Clone the repository and install dependencies:
+To start using @intrig/react, simply install the package in your React project:
 
 ```bash
-$ git clone https://github.com/your-username/intrig.git
-$ cd intrig
-$ npm install
-
+npm install @intrig/react
 ```
 
+This package will allow you to leverage autogenerated code for a variety of purposes within your React app, saving development time and reducing boilerplate.
+
+## Contributing
+
+We welcome contributions! Feel free to check out the [contribution guide](https://github.com/intrigsoft/intrig/blob/main/CONTRIBUTING.md) in the main repository.
+
 ## License
 
-Intrig is open source software licensed under the [MIT License](LICENSE).
+@intrig/react is licensed under the MIT License. See the [LICENSE](https://github.com/intrigsoft/intrig/blob/main/LICENSE) file for more information.
+
+## Links
 
-## Contribution
+- [Main GitHub Repository](https://github.com/intrigsoft/intrig)
 
-We welcome contributions! Please read our [contributing guide](CONTRIBUTING.md) to learn how you can get involved.
+## Support
 
-## Contact
+For questions, suggestions, or assistance, please open an issue on the [GitHub repository](https://github.com/intrigsoft/intrig/issues).
 
-For questions or feedback, feel free to reach out at [support@intrigsoft.com](mailto\:support@intrigsoft.com).

package/eslint.config.cjs

@@ -0,0 +1,12 @@
+const nx = require('@nx/eslint-plugin');
+const baseConfig = require('../../eslint.base.config.js');
+
+module.exports = [
+  ...baseConfig,
+  ...nx.configs['flat/react'],
+  {
+    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+    // Override or add rules here
+    rules: {},
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intrig/react",
-  "version": "1.0.6",
+  "version": "1.0.10",
   "main": "./index.js",
   "types": "./index.d.ts",
   "private": false,
@@ -22,8 +22,8 @@
     "fast-xml-parser": "^4.5.0"
   },
   "peerDependencies": {
-    "react": "18.3.1",
-    "react-dom": "18.3.1"
+    "react": ">=18.0.0 || ^19.0.0-rc",
+    "react-dom": ">=18.0.0 || ^19.0.0-rc"
   },
   "devDependencies": {
     "@types/glob": "^8.1.0"
@@ -31,6 +31,5 @@
   "_moduleAliases": {
     "@intrig/react": "./src"
   },
-  "type": "module",
-  "module": "./index.esm.js"
-}
+  "type": "module"
+}

package/project.json

@@ -0,0 +1,9 @@
+{
+  "name": "client-react",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "lib/client-react/src",
+  "projectType": "library",
+  "tags": ["react intrig code-generation"],
+  "// targets": "to see all targets run: nx show project client-react --web",
+  "targets": {}
+}

package/rollup.config.cjs

@@ -0,0 +1,28 @@
+const { withNx } = require('@nx/rollup/with-nx');
+const url = require('@rollup/plugin-url');
+const svg = require('@svgr/rollup');
+
+module.exports = withNx(
+  {
+    main: './src/index.ts',
+    outputPath: '../../dist/lib/client-react',
+    tsConfig: './tsconfig.lib.json',
+    compiler: 'babel',
+    external: ['react', 'react-dom', 'react/jsx-runtime'],
+    format: ['esm'],
+    assets: [{ input: '.', output: '.', glob: 'README.md' }],
+  },
+  {
+    // Provide additional rollup configuration here. See: https://rollupjs.org/configuration-options
+    plugins: [
+      svg({
+        svgo: false,
+        titleProp: true,
+        ref: true,
+      }),
+      url({
+        limit: 10000, // 10kB
+      }),
+    ],
+  }
+);

package/src/extra/{index.d.ts → index.ts}

@@ -1,4 +1,4 @@
 export * from './useResolvedValue';
 export * from './useResolvedCachedValue';
-export * from './useAsPromise';
-export * from './useAsNetworkState';
+export * from './useAsPromise'
+export * from './useAsNetworkState'

package/src/extra/useAsNetworkState.ts

@@ -0,0 +1,53 @@
+import { error, init, NetworkState, pending, success } from '@intrig/react/network-state';
+import { useCallback, useId, useMemo } from 'react';
+import { useIntrigContext } from '@intrig/react/intrig-context';
+
+/**
+ * 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 function useAsNetworkState<T, F extends ((...args: any) => Promise<T>)>(fn: F, key = 'default'): [NetworkState<T>, (...params: Parameters<F>) => void, () => void] {
+  const id = useId();
+
+  const context = useIntrigContext();
+
+  const networkState = useMemo(() => {
+    return context.state?.[`promiseState:${id}:${key}}`] ?? init()
+  }, [context.state?.[`promiseState:${id}:${key}}`]]);
+
+  const dispatch = useCallback(
+    (state: NetworkState<T>) => {
+      context.dispatch({ key, operation: id, source: 'promiseState', state });
+    },
+    [key, context.dispatch]
+  );
+
+  const execute = useCallback((...args: Parameters<F>) => {
+    dispatch(pending())
+    return fn(...args).then(
+      (data) => {
+        dispatch(success(data))
+      },
+      (e) => {
+        dispatch(error(e))
+      }
+    )
+  }, []);
+
+  const clear = useCallback(() => {
+    dispatch(init())
+  }, []);
+
+  return [
+    networkState,
+    execute,
+    clear
+  ]
+}

package/src/extra/{useAsPromise.d.ts → useAsPromise.ts}

@@ -1,4 +1,15 @@
-import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+import {
+  BinaryFunctionHook,
+  BinaryHookOptions,
+  BinaryProduceHook,
+  ConstantHook, IntrigHook, IntrigHookOptions, isError, isSuccess, isValidationError, UnaryFunctionHook,
+  UnaryHookOptions,
+  UnaryProduceHook,
+  UnitHook,
+  UnitHookOptions
+} from '@intrig/react/network-state';
+import { useCallback, useEffect, useRef } from 'react';
+
 /**
  * Transforms a unit hook into a promise, enabling asynchronous usage of the hook's lifecycle or events.
  *
@@ -7,7 +18,8 @@ import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook,
  * @return {[() => Promise<never>, () => void]} A tuple containing a function that returns a promise resolving with the hook's completion
  * result or rejecting with an error, and a function to clean up the hook's resources when no longer needed.
  */
-export declare function useAsPromise<E>(hook: UnitHook<E>, options: UnitHookOptions): [() => Promise<never>, () => void];
+export function useAsPromise<E>(hook: UnitHook<E>, options: UnitHookOptions): [() => Promise<never>, () => void];
+
 /**
  * Converts a constant hook into a promise-based interface that can be invoked and reset.
  *
@@ -15,7 +27,8 @@ export declare function useAsPromise<E>(hook: UnitHook<E>, options: UnitHookOpti
  * @param {UnitHookOptions} options - Configuration options for the hook behavior.
  * @return {[() => Promise<T>, () => void]} A tuple where the first element is a function that returns a promise resolving with the hook value, and the second element is a reset function.
  */
-export declare function useAsPromise<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): [() => Promise<T>, () => void];
+export function useAsPromise<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): [() => Promise<T>, () => void];
+
 /**
  * Wraps the provided hook function to return a promise-based API, offering more flexibility
  * in asynchronous operations. This utility converts the hook into a callable function that
@@ -27,7 +40,8 @@ export declare function useAsPromise<T, E>(hook: ConstantHook<T, E>, options: Un
  * is a function that takes the hook's parameters and returns a `Promise`, and the second element
  * is a cleanup function for resource management.
  */
-export declare function useAsPromise<P, E>(hook: UnaryProduceHook<P, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<never>, () => void];
+export function useAsPromise<P, E>(hook: UnaryProduceHook<P, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<never>, () => void];
+
 /**
  * Allows the usage of a hook's asynchronous behavior as a Promise.
  *
@@ -37,7 +51,8 @@ export declare function useAsPromise<P, E>(hook: UnaryProduceHook<P, E>, options
  *     - A function that accepts parameters and returns a Promise resolving to the hook's result.
  *     - A cleanup function to properly dispose of the hook when no longer needed.
  */
-export declare function useAsPromise<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<T>, () => void];
+export function useAsPromise<P, T, E>(  hook: UnaryFunctionHook<P, T, E>, options?: UnaryHookOptions<P>): [(params: P) => Promise<T>, () => void];
+
 /**
  * Converts a binary hook into a promise-based function, allowing the hook to be used asynchronously.
  *
@@ -48,7 +63,8 @@ export declare function useAsPromise<P, T, E>(hook: UnaryFunctionHook<P, T, E>,
  * @param {BinaryHookOptions<P, B>} [options] Optional configuration for the binary hook.
  * @return {[(body: B, params: P) => Promise<never>, () => void]} A tuple where the first element is a function that returns a promise and the second is a cleanup function.
  */
-export declare function useAsPromise<P, B, E>(hook: BinaryProduceHook<P, B, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<never>, () => void];
+export function useAsPromise<P, B, E>(hook: BinaryProduceHook<P, B, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<never>, () => void];
+
 /**
  * Wraps a binary function hook into a promise-based interface.
  *
@@ -56,4 +72,39 @@ export declare function useAsPromise<P, B, E>(hook: BinaryProduceHook<P, B, E>,
  * @param {BinaryHookOptions<P, B>} [options] Optional configuration options for the hook.
  * @return {[function(B, P): Promise<T>, function(): void]} Returns a tuple containing a function that invokes the hook and returns a promise, and a cleanup function to dispose of the hook's resources.
  */
-export declare function useAsPromise<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<T>, () => void];
+export function useAsPromise<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options?: BinaryHookOptions<P, B>): [(body: B, params: P) => Promise<T>, () => void];
+
+// **Implementation**
+export function useAsPromise<P, B, T, E>(
+  hook: IntrigHook<P, B, T, E>,
+  options?: IntrigHookOptions<P, B>
+): [(...args: any[]) => Promise<T>, () => void] {  // <- Compatible return type
+  const resolveRef = useRef<(value: T) => void>();
+  const rejectRef = useRef<(reason?: any) => void>();
+
+  const [state, dispatch, clear] = hook(options as any); // Casting to `any` to match all overloads
+
+  useEffect(() => {
+    if (isSuccess(state)) {
+      resolveRef.current?.(state.data);
+      clear();
+    } else if (isError(state)) {
+      rejectRef.current?.(state.error);
+      clear();
+    }
+  }, [state]);
+
+  const promiseFn = useCallback((...args: any[]) => {
+    return new Promise<T>((resolve, reject) => {
+      resolveRef.current = resolve;
+      rejectRef.current = reject;
+
+      const dispatchState = (dispatch as any)(...args);
+      if (isValidationError(dispatchState)) {
+        reject(dispatchState.error);
+      }
+    });
+  }, [dispatch]);
+
+  return [promiseFn, clear];
+}

package/src/extra/{useResolvedCachedValue.d.ts → useResolvedCachedValue.ts}

@@ -1,4 +1,15 @@
-import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+import {
+  BinaryFunctionHook,
+  BinaryHookOptions,
+  BinaryProduceHook,
+  ConstantHook, IntrigHook, IntrigHookOptions, isSuccess, UnaryFunctionHook,
+  UnaryHookOptions,
+  UnaryProduceHook,
+  UnitHook,
+  UnitHookOptions
+} from '@intrig/react/network-state';
+import { useEffect, useState } from 'react';
+
 /**
  * Resolves and caches the computed value of a given hook.
  *
@@ -6,7 +17,8 @@ import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook,
  * @param {UnitHookOptions} options - Options to customize the behavior of the hook resolution and caching process.
  * @return {undefined} This function does not return a value.
  */
-export declare function useResolvedCachedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+export function useResolvedCachedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+
 /**
  * Resolves and retrieves a cached value by utilizing a specified hook and options.
  *
@@ -14,7 +26,8 @@ export declare function useResolvedCachedValue<E>(hook: UnitHook<E>, options: Un
  * @param {UnitHookOptions} options - Options controlling the behavior or configuration of the hook.
  * @return {T | undefined} The resolved cached value or undefined if the value couldn't be determined.
  */
-export declare function useResolvedCachedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
+export function useResolvedCachedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
+
 /**
  * Resolves and caches the value produced by the specified hook.
  * This utility helps in managing hook-driven computational results within a component context by caching
@@ -24,7 +37,8 @@ export declare function useResolvedCachedValue<T, E>(hook: ConstantHook<T, E>, o
  * @param {UnaryHookOptions<P>} options - The configuration options that control how the hook is executed.
  * @return {undefined} Returns undefined since the resolution and caching of the value are managed internally.
  */
-export declare function useResolvedCachedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+export function useResolvedCachedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+
 /**
  * Resolves a cached value using the provided hook and options.
  *
@@ -33,7 +47,8 @@ export declare function useResolvedCachedValue<P, E>(hook: UnaryProduceHook<P, E
  * @param {UnaryHookOptions<P>} options - Configuration settings or arguments required by the hook to retrieve the cached value.
  * @return {T | undefined} A value of type T if resolved successfully, or undefined if not available.
  */
-export declare function useResolvedCachedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+export function useResolvedCachedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+
 /**
  * Resolves and caches the value produced by the provided binary hook function.
  * This function ensures that the hook's resolved value is reused efficiently across invocations
@@ -43,7 +58,8 @@ export declare function useResolvedCachedValue<P, T, E>(hook: UnaryFunctionHook<
  * @param {BinaryHookOptions<P, B>} options - Configuration options for controlling the behavior of the hook and its caching mechanism.
  * @return {undefined} - Returns undefined as the resolution is managed internally via the hook's lifecycle.
  */
-export declare function useResolvedCachedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+export function useResolvedCachedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+
 /**
  * A hook utility function that resolves and caches a value based on the given binary function hook and options.
  *
@@ -51,4 +67,20 @@ export declare function useResolvedCachedValue<P, B, E>(hook: BinaryProduceHook<
  * @param {BinaryHookOptions<P, B>} options - The options object containing parameters and configuration for the hook.
  * @return {T | undefined} The resolved and cached value, or undefined if it cannot be resolved.
  */
-export declare function useResolvedCachedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;
+export function useResolvedCachedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;
+
+// **Implementation**
+export function useResolvedCachedValue<P, B, T, E>(hook: IntrigHook<P, B, T, E>, options: IntrigHookOptions<P, B>): T | undefined {
+  const [cachedValue, setCachedValue] = useState<T | undefined>();
+
+  const [state] = hook(options as any); // Ensure compatibility with different hook types
+
+  useEffect(() => {
+    if (isSuccess(state)) {
+      setCachedValue(state.data);
+    }
+    // Do not clear cached value if state is unsuccessful
+  }, [state]);
+
+  return cachedValue;
+}

package/src/extra/{useResolvedValue.d.ts → useResolvedValue.ts}

@@ -1,4 +1,15 @@
-import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook, UnaryFunctionHook, UnaryHookOptions, UnaryProduceHook, UnitHook, UnitHookOptions } from '@intrig/react/network-state';
+import {
+  BinaryFunctionHook,
+  BinaryHookOptions,
+  BinaryProduceHook,
+  ConstantHook, IntrigHook, IntrigHookOptions, isSuccess, UnaryFunctionHook,
+  UnaryHookOptions,
+  UnaryProduceHook,
+  UnitHook,
+  UnitHookOptions
+} from '@intrig/react/network-state';
+import { useEffect, useState } from 'react';
+
 /**
  * A function that resolves the value provided by a unit hook based on specified options.
  *
@@ -6,7 +17,8 @@ import { BinaryFunctionHook, BinaryHookOptions, BinaryProduceHook, ConstantHook,
  * @param {UnitHookOptions} options - Configuration options to control how the unit hook is resolved.
  * @return {undefined} Returns undefined after resolving the unit hook value.
  */
-export declare function useResolvedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+export function useResolvedValue<E>(hook: UnitHook<E>, options: UnitHookOptions): undefined;
+
 /**
  * Resolves the value of a given constant hook based on the provided options.
  *
@@ -14,7 +26,7 @@ export declare function useResolvedValue<E>(hook: UnitHook<E>, options: UnitHook
  * @param {UnitHookOptions} options - The options used to configure the resolution of the hook value.
  * @return {T | undefined} The resolved value of the hook or undefined if the hook cannot be resolved.
  */
-export declare function useResolvedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
+export function useResolvedValue<T, E>(hook: ConstantHook<T, E>, options: UnitHookOptions): T | undefined;
 /**
  * This function is a utility hook that evaluates and resolves the value of the provided hook function.
  * It takes a hook function and its corresponding options as arguments to produce side effects or state updates.
@@ -23,7 +35,8 @@ export declare function useResolvedValue<T, E>(hook: ConstantHook<T, E>, options
  * @param {UnaryHookOptions<P>} options - Configuration options for the hook, such as parameters or behaviors.
  * @return {undefined} This function does not return a value; it operates through side effects or resolves implicitly.
  */
-export declare function useResolvedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+export function useResolvedValue<P, E>(hook: UnaryProduceHook<P, E>, options: UnaryHookOptions<P>): undefined;
+
 /**
  * A custom hook that provides a resolved value based on the provided unary function hook and options.
  *
@@ -31,7 +44,8 @@ export declare function useResolvedValue<P, E>(hook: UnaryProduceHook<P, E>, opt
  * @param {UnaryHookOptions<P>} options - The configuration object containing parameters for the unary hook execution.
  * @return {T | undefined} The resolved value of type T if successful, or undefined if no value is resolved.
  */
-export declare function useResolvedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+export function useResolvedValue<P, T, E>(hook: UnaryFunctionHook<P, T, E>, options: UnaryHookOptions<P>): T | undefined;
+
 /**
  * A custom hook that processes a binary produce hook and its options to produce a resolved value.
  *
@@ -39,7 +53,8 @@ export declare function useResolvedValue<P, T, E>(hook: UnaryFunctionHook<P, T,
  * @param {BinaryHookOptions<P, B>} options - The options provided to the binary hook for processing.
  * @return {undefined} Returns `undefined` after the hook is resolved.
  */
-export declare function useResolvedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+export function useResolvedValue<P, B, E>(hook: BinaryProduceHook<P, B, E>, options: BinaryHookOptions<P, B>): undefined;
+
 /**
  * Resolves a value based on the provided binary function hook and options.
  *
@@ -47,4 +62,21 @@ export declare function useResolvedValue<P, B, E>(hook: BinaryProduceHook<P, B,
  * @param {BinaryHookOptions<P, B>} options - Configuration options for the binary function hook.
  * @return {T | undefined} The resolved value of type T, or undefined if the resolution fails.
  */
-export declare function useResolvedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;
+export function useResolvedValue<P, B, T, E>(hook: BinaryFunctionHook<P, B, T, E>, options: BinaryHookOptions<P, B>): T | undefined;
+
+// **Implementation**
+export function useResolvedValue<P, B, T, E>(hook: IntrigHook<P, B, T, E>, options: IntrigHookOptions<P, B>): T | undefined {
+  const [value, setValue] = useState<T | undefined>();
+
+  const [state] = hook(options as any); // Ensure compatibility with different hook types
+
+  useEffect(() => {
+    if (isSuccess(state)) {
+      setValue(state.data);
+    } else {
+      setValue(undefined);
+    }
+  }, [state]); // Add `state` to the dependency array to ensure updates
+
+  return value;
+}

package/src/{index.d.ts → index.ts}

@@ -1,4 +1,4 @@
 export * from './intrig-provider';
 export * from './network-state';
-export * from './extra/index';
-export * from './media-type-utils';
+export * from './extra/index'
+export * from './media-type-utils'

package/src/intrig-context.ts

@@ -0,0 +1,66 @@
+import { NetworkAction, NetworkState } from '@intrig/react/network-state';
+import { AxiosProgressEvent } from 'axios';
+import { ZodSchema } from 'zod';
+import { createContext, useContext } from 'react';
+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; // This allows transformations, while retaining flexibility.
+  originalData?: T; // Keeps track of the original data type.
+  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}
+ */
+const Context = createContext<ContextType>({
+  state: {},
+  filteredState: {},
+  dispatch() {
+    //noop
+  },
+  configs: {},
+  async execute() {
+    //noop
+  }
+});
+
+export function useIntrigContext() {
+  return useContext(Context);
+}
+
+export {
+  Context,
+  GlobalState,
+  RequestType,
+}