@intrig/react 1.0.7 → 1.0.11

package/.babelrc

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

package/README.md

@@ -1,178 +1,35 @@
-<p align="center">
-<img src="./docs/intrig-logo.svg" alt="Intrig Logo" width="200">
-</p>
+# @intrig/react
 
-# Intrig 
-![npm](https://img.shields.io/npm/v/intrig) 
-![License](https://img.shields.io/github/license/intrigsoft/intrig)
-![TypeScript](https://img.shields.io/github/package-json/dependency-version/intrigsoft/intrig/dev/typescript)
-![React](https://img.shields.io/npm/dependency-version/@intrig/react/peer/react)
-![Next.js](https://img.shields.io/npm/dependency-version/@intrig/next/peer/next)
-
-Intrig is a powerful API integration and documentation tool designed for frontend developers working with OpenAPI 3. It streamlines API consumption by generating boilerplate code, offering a rich documentation interface, and providing an intuitive way to explore and interact with API endpoints.
+@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.
 
 ## Features
 
-### 🔹 API Documentation & Exploration
-
-- Generates structured documentation from OpenAPI 3 specifications.
-- Provides an interactive UI to explore API endpoints, including request and response types.
-- Enables developers to view version history of API definitions.
-
-### 🔹 Code Generation
-
-- Generates strongly typed hooks for API calls, integrating seamlessly with React applications.
-
-- Provides hooks that follow React’s standard state management conventions, resembling `useState` syntax for simplicity and performance.
-
-### 🔹 CLI Tooling
-
-- Allows automation of API integration workflows.
-- Supports syncing remote OpenAPI specifications.
-- Provides an easy way to manage API configurations.
-
-
-
-## Installation
-
-Intrig CLI is published to npx. When you run `npx intrig init`, it adds necessary dependencies to the project, such as `@intrig/next` for Next.js projects or `@intrig/react` for React projects. It also adds `intrig` as a dev dependency to the project.
-
-```sh
-npx intrig init
-```
-
-## Usage
-
-### CLI Usage
-
-Intrig provides a command-line interface for managing API integrations efficiently. Below are the available commands:
-
-#### `init`
-
-Initializes a new Intrig configuration and installs necessary dependencies.
-
-```sh
-npx intrig init
-```
-
-#### `add`
-
-Adds a new API source to the Intrig configuration.
-
-```sh
-intrig add [-s <value>] [-i <value>]
-```
-
-- `-i, --id=<value>`: Unique ID for the API.
-- `-s, --source=<value>`: OpenAPI specification URL.
-
-#### `ls`
-
-Lists API sources from the Intrig configuration.
+- **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.
 
-```sh
-intrig ls [-d] [-f <value>]
-```
-
-- `-d, --detailed`: Show detailed information.
-- `-f, --filter=<value>`: Filter sources by name or ID.
-
-#### `baseline`
-
-Creates a baseline version for API specifications.
-
-```sh
-intrig baseline -i <value> -v <value> [-f]
-```
-
-- `-i, --id=<value>`: API ID to baseline.
-- `-v, --version=<value>`: Version for the baseline.
-- `-f, --force`: Force baseline if version exists.
+## Getting Started
 
-#### `sync`
+To start using @intrig/react, simply install the package in your React project:
 
-Synchronizes API specifications.
-
-```sh
-intrig sync [-a | -i <value>...]
+```bash
+npm install @intrig/react
 ```
 
-- `-a, --all`: Sync all APIs.
-- `-i, --ids=<value>...`: Comma-separated list of API IDs to sync.
-
-#### `generate`
-
-Regenerates code for API integration.
-
-```sh
-intrig generate [-a | -i <value>...]
-```
-
-- `-a, --all`: Sync all APIs.
-- `-i, --ids=<value>...`: Comma-separated list of API IDs to sync.
-
-#### `rm`
+This package will allow you to leverage autogenerated code for a variety of purposes within your React app, saving development time and reducing boilerplate.
 
-Removes an API source from the Intrig configuration.
-
-```sh
-intrig rm [SOURCE]
-```
-
-- `SOURCE`: ID of the source to remove.
-
-#### `insight`
-
-Starts the web view for Intrig insight.
-
-```sh
-intrig insight [-p <value>] [-d]
-```
-
-- `-p, --port=<value>`: Port for Next.js server (default: 7007).
-- `-d, --debug`: Enable debug mode for server-side logs.
-
-## Configuration
-
-Intrig supports project-level configurations via `intrig.config.json`:
-
-```json
-{
-  "sources": [
-    {
-      "id": "example-api",
-      "name": "Example API Definition",
-      "specUrl": "https://example.com/api/openapi.json"
-    },
-    {
-      "id": "analytics",
-      "name": "Analytics API",
-      "specUrl": "https://api.analytics.com/v3/openapi.json"
-    }
-  ],
-  "generator": "next"
-}
-```
+## Contributing
 
-- **`sources`**: Defines the API sources available for integration.
-  - `id`: A unique identifier for the API.
-  - `name`: A human-readable name for the API.
-  - `specUrl`: The URL of the OpenAPI 3 specification.
-- **`generator`**: Specifies the type of code generation, such as `next` for Next.js projects.
+We welcome contributions! Feel free to check out the [contribution guide](https://github.com/intrigsoft/intrig/blob/main/CONTRIBUTING.md) in the main repository.
 
-## Roadmap
+## License
 
-- ✅ OpenAPI-based documentation and code generation
-- ✅ CLI tool for API exploration and integration
-- ⏳ Streamline file download feature
-- ⏳ Remix integration
-- ⏳ Vue.js integration
+@intrig/react is licensed under the MIT License. See the [LICENSE](https://github.com/intrigsoft/intrig/blob/main/LICENSE) file for more information.
 
-## Contributing
+## Links
 
-We welcome contributions! Please check our issues board and submit pull requests.
+- [Main GitHub Repository](https://github.com/intrigsoft/intrig)
 
-## License
+## Support
 
-Apache License 2.0. See `LICENSE` file for details.
+For questions, suggestions, or assistance, please open an issue on the [GitHub repository](https://github.com/intrigsoft/intrig/issues).
 

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.7",
+  "version": "1.0.11",
   "main": "./index.js",
   "types": "./index.d.ts",
   "private": false,
@@ -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: string = 'default'): [NetworkState<T>, (...params: Parameters<F>) => void, () => void] {
+  let id = useId();
+
+  let 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>();
+
+  let [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;
+
+      let 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>();
+
+  let [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>();
+
+  let [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'