@react-xp/fetch 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/cjs/fetchContext.js

@@ -0,0 +1,26 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchContext = void 0;
+const react_1 = require("react");
+/**
+ * React context for managing fetch configurations and global parameters.
+ *
+ * @remarks
+ * This context provides default values for fetch configurations, a method to retrieve namespace-specific configs,
+ * an initialization flag, and a setter for global parameters.
+ *
+ * @property {Object} configs - Global fetch configurations.
+ * @property {Function} getNamespaceConfig - Returns configuration and handlers for a specific namespace.
+ * @property {boolean} isInitialized - Indicates if the context has been initialized.
+ * @property {Function} setGlobalParameters - Sets global parameters for fetch operations.
+ */
+exports.fetchContext = (0, react_1.createContext)({
+    configs: {},
+    getNamespaceConfig: () => ({
+        configs: { baseUrl: 'http://localhost:3000', cache: {} },
+        handlers: { onError: () => { } },
+    }),
+    isInitialized: false,
+    setGlobalParameters: () => { },
+});

package/dist/cjs/fetchCore.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCore = void 0;
+const utils_1 = require("@react-xp/utils");
+const fetchCore = async ({ data, globalParameters, handlers, headers, method, signal, staticResponse, url, }) => {
+    const handleOnError = async (error) => {
+        // ignore parsing error caused by abort
+        if (error === 'user_cancelled' || error?.name === 'AbortError') {
+            return {};
+        }
+        handlers?.onError?.(error, null);
+        throw error;
+    };
+    try {
+        handlers?.onRequestStart?.();
+        const defaultValues = {
+            body: data,
+            globalParameters: globalParameters || {},
+            headers: headers || {},
+        };
+        const { body: preparedBody, headers: preparedHeaders } = handlers?.onRequestPrepare?.(defaultValues) || defaultValues;
+        const masterUrl = url.replace(/\/+/g, '/').replace(':/', '://');
+        const transformedUrl = (0, utils_1.transformTemplateString)({
+            template: masterUrl,
+            values: {
+                ...defaultValues.globalParameters,
+                ...preparedBody,
+            },
+        });
+        let res;
+        if (staticResponse) {
+            res = await staticResponse();
+        }
+        else {
+            const response = await fetch(transformedUrl.value, {
+                method,
+                headers: preparedHeaders,
+                body: preparedBody ? JSON.stringify(preparedBody) : undefined,
+                signal,
+            });
+            if (!response.ok) {
+                return handleOnError(response);
+            }
+            res = await response.json();
+        }
+        if (res.metadata?.status?.toLowerCase() === 'error') {
+            return handleOnError(res);
+        }
+        return res;
+    }
+    catch (error) {
+        return handleOnError(error);
+    }
+    finally {
+        handlers?.onRequestEnd?.();
+    }
+};
+exports.fetchCore = fetchCore;

package/dist/cjs/fetchProvider.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_query_1 = require("@tanstack/react-query");
+const fetchContext_1 = require("./fetchContext");
+const queryClient = new react_query_1.QueryClient();
+const _namespaceConfigs = {};
+/**
+ * Provides fetch configuration and handlers for a specific namespace to its child components.
+ *
+ * This provider initializes and manages fetch-related context, including configuration and handlers,
+ * for a given namespace. It ensures that the context is properly initialized before rendering children,
+ * and exposes methods to get namespace-specific configuration and set global parameters.
+ *
+ * @param {FetchProviderProps} props - The properties for the FetchProvider component.
+ * @param {React.ReactNode} props.children - The child components to be rendered within the provider.
+ * @param {TFetchConfigForNamespace} props.configs - The fetch configuration for the specified namespace.
+ * @param {any} props.handlers - The handlers associated with the fetch configuration.
+ * @param {TFetchNamespaces} props.namespace - The namespace for which the fetch configuration applies.
+ *
+ * @throws {Error} If the requested namespace configuration is not found.
+ *
+ * @returns {JSX.Element} The provider wrapping its children with the fetch context and query client provider.
+ */
+const FetchProvider = ({ children, configs, handlers, namespace, }) => {
+    _namespaceConfigs[namespace] = { configs, handlers };
+    const handleGetNamespaceConfig = (namespace) => {
+        if (!Object.getOwnPropertyNames(_namespaceConfigs).includes(namespace)) {
+            throw new Error(`FetchProvider: namespace "${namespace}" not found! Make sure to use the correct namespace or to wrap your component tree with a FetchProvider with the correct namespace.`);
+        }
+        return _namespaceConfigs[namespace];
+    };
+    const handleSetGlobalParameters = (namespace, globalParameters) => {
+        if (_namespaceConfigs?.[namespace]) {
+            _namespaceConfigs[namespace].configs.globalParameters = globalParameters;
+        }
+    };
+    return ((0, jsx_runtime_1.jsx)(fetchContext_1.fetchContext.Provider, { value: {
+            configs: _namespaceConfigs,
+            getNamespaceConfig: handleGetNamespaceConfig,
+            isInitialized: true,
+            setGlobalParameters: handleSetGlobalParameters,
+        }, children: (0, jsx_runtime_1.jsx)(react_query_1.QueryClientProvider, { client: queryClient, children: children }) }));
+};
+exports.FetchProvider = FetchProvider;

package/dist/cjs/fetchTypes.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=fetchTypes.js.map

package/dist/cjs/index.js

@@ -14,10 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./fetchHelper"), exports);
-__exportStar(require("./fetchModule"), exports);
+__exportStar(require("./fetchCore"), exports);
+__exportStar(require("./fetchProvider"), exports);
 __exportStar(require("./fetchTypes"), exports);
-__exportStar(require("./useFetch"), exports);
 __exportStar(require("./useFetchMutation"), exports);
 __exportStar(require("./useFetchQuery"), exports);
-//# sourceMappingURL=index.js.map
+__exportStar(require("./useFetchUtils"), exports);

package/dist/cjs/useFetchContext.js

@@ -0,0 +1,28 @@
+"use strict";
+'use client';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchContext = void 0;
+const react_1 = __importDefault(require("react"));
+const fetchContext_1 = require("./fetchContext");
+/**
+ * Custom hook to access the fetch context.
+ *
+ * This hook retrieves the current fetch context using React's `useContext`.
+ * It also checks if the fetch module has been initialized, and logs an error
+ * to the console if it has not been initialized.
+ *
+ * @returns The current fetch context.
+ */
+const useFetchContext = () => {
+    const context = react_1.default.useContext(fetchContext_1.fetchContext);
+    react_1.default.useEffect(() => {
+        if (!context.isInitialized) {
+            console.error('Fetch module is not initialized! Using FetchProvider to initialized.');
+        }
+    }, [context]);
+    return context;
+};
+exports.useFetchContext = useFetchContext;

package/dist/cjs/useFetchCore.js

@@ -0,0 +1,229 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchCore = void 0;
+const react_1 = require("react");
+const fetchCore_1 = require("./fetchCore");
+const useFetchContext_1 = require("./useFetchContext");
+function composeAbortSignal(...signals) {
+    const s = signals.filter(Boolean);
+    for (const x of s) {
+        if (x.aborted)
+            return AbortSignal.abort(x.reason);
+    }
+    const ctrl = new AbortController();
+    const onAbort = (ev) => {
+        if (!ctrl.signal.aborted) {
+            ctrl.abort(ev?.target?.reason ?? 'aborted');
+        }
+    };
+    for (const x of s) {
+        x.addEventListener('abort', onAbort, { once: true });
+    }
+    return ctrl.signal;
+}
+/**
+ * Custom React hook for performing fetch operations with advanced configuration and lifecycle handlers.
+ *
+ * @template TInput - The type of the input data for the fetch request.
+ * @template TOutput - The type of the output data expected from the fetch response. Must extend `TFetchDefaultOutput`.
+ * @template TTransformOutput - The type of the transformed output data. Defaults to `TOutput`.
+ *
+ * @param params - The configuration object for the fetch operation.
+ * @param params.data - The input data to be sent with the request.
+ * @param params.key - Unique key for caching and query identification.
+ * @param params.method - HTTP method to use for the request (default: 'GET').
+ * @param params.namespace - Namespace for fetching configuration and handlers.
+ * @param params.onError - Optional callback invoked on error response.
+ * @param params.onSuccess - Optional callback invoked on successful response.
+ * @param params.options - Additional options for fetch behavior, caching, and loading indicators.
+ * @param params.path - API endpoint path to be appended to the base URL.
+ * @param params.transform - Optional function to transform the response data.
+ *
+ * @returns An object containing utility functions:
+ * - `getBaseReactQueryInput`: Returns base configuration for React Query hooks.
+ * - `getCommonFetchResponse`: Normalizes fetch/mutation responses for consistent usage.
+ * - `getFetchTreatment`: Executes the fetch request with configured handlers and returns the processed result.
+ * - `onSuccess`: Handles invocation of the success callback, ensuring it is called only once per request.
+ *
+ * @remarks
+ * - Integrates with a context-based configuration system for headers, global parameters, and error handling.
+ * - Supports aborting requests and custom loading indicators.
+ * - Designed for use with React Query and custom fetch logic in modular applications.
+ */
+const useFetchCore = ({ data: inputData, key, method = 'GET', namespace, onError, onSuccess, options, path, select, staticResponse, }) => {
+    const { getNamespaceConfig } = (0, useFetchContext_1.useFetchContext)();
+    const fetchConfigs = getNamespaceConfig(namespace);
+    const lastDataUpdatedAt = (0, react_1.useRef)(0);
+    const fetchSignal = (0, react_1.useRef)(new AbortController());
+    const handleGetBaseReactQueryInput = () => ({
+        enabled: options?.enabled ?? true,
+        gcTime: (options?.cache?.cacheTime ||
+            fetchConfigs.configs.cache?.cacheTime ||
+            0) * 1000,
+        queryKey: [key, inputData],
+        mutationKey: [key],
+        select: (data) => select?.(data, inputData) || data,
+        staleTime: (options?.cache?.staleTime ||
+            fetchConfigs.configs.cache?.staleTime ||
+            0) * 1000,
+    });
+    // const handleGetFetchTreatment = async ({
+    //   body,
+    //   signal,
+    // }: { body?: TAny; signal?: AbortSignal }) => {
+    //   const handleOnError = (error: TAny) => {
+    //     // ignore parsing error caused by abort
+    //     if (error === 'user_cancelled' || error?.name === 'AbortError') {
+    //       return {} as TTransformOutput;
+    //     }
+    //     if (onError) {
+    //       const raiseUp = onError(error, null);
+    //       if (raiseUp) {
+    //         fetchConfigs.handlers.onError(error);
+    //       }
+    //     } else {
+    //       fetchConfigs.handlers.onError(error);
+    //     }
+    //     throw error;
+    //   };
+    //   try {
+    //     fetchConfigs.handlers.onRequestStart?.({
+    //       showLoading: options?.showLoading || false,
+    //     });
+    //     const combinedSignal =
+    //       (AbortSignal as TAny).any?.(
+    //         [fetchSignal.current.signal, signal].filter(Boolean),
+    //       ) ?? composeAbortSignal(fetchSignal.current.signal, signal);
+    //     const defaultValues: TFetchHandlersOnRequestPrepareIn = {
+    //       body: body || inputData,
+    //       globalParameters: fetchConfigs.configs.globalParameters || {},
+    //       headers: fetchConfigs.configs.headers || {},
+    //     };
+    //     const { body: preparedBody, headers: preparedHeaders } =
+    //       fetchConfigs.handlers.onRequestPrepare?.(defaultValues) ||
+    //       defaultValues;
+    //     const url = `${fetchConfigs.configs.baseUrl}/${path}`
+    //       .replace(/\/+/g, '/')
+    //       .replace(':/', '://');
+    //     const transformedUrl = transformTemplateString({
+    //       template: url,
+    //       values: {
+    //         ...defaultValues.globalParameters,
+    //         ...preparedBody,
+    //       },
+    //     });
+    //     console.log('useFetchCore :: handleGetFetchTreatment :: url', {
+    //       url,
+    //       transformedUrl,
+    //       values: { ...defaultValues.globalParameters, preparedBody },
+    //     });
+    //     const response = await fetch(transformedUrl.value, {
+    //       method,
+    //       headers: preparedHeaders,
+    //       body: preparedBody ? JSON.stringify(preparedBody) : undefined,
+    //       signal: combinedSignal,
+    //     });
+    //     if (!response.ok) {
+    //       return handleOnError(response);
+    //     }
+    //     const res = await response.json();
+    //     if (res.metadata?.status?.toLowerCase() === 'error') {
+    //       return handleOnError(res);
+    //     }
+    //     return res;
+    //   } catch (error) {
+    //     return handleOnError(error);
+    //   } finally {
+    //     fetchConfigs.handlers.onRequestEnd?.({
+    //       showLoading: options?.showLoading || false,
+    //     });
+    //   }
+    // };
+    const handleGetFetchTreatment = async ({ body, signal, }) => {
+        const combinedSignal = AbortSignal.any?.([fetchSignal.current.signal, signal].filter(Boolean)) ?? composeAbortSignal(fetchSignal.current.signal, signal);
+        return (0, fetchCore_1.fetchCore)({
+            data: body || inputData,
+            globalParameters: fetchConfigs.configs.globalParameters || {},
+            handlers: {
+                onError: (error) => {
+                    if (onError) {
+                        const raiseUp = onError(error, null);
+                        if (raiseUp) {
+                            fetchConfigs.handlers.onError(error);
+                        }
+                    }
+                    else {
+                        fetchConfigs.handlers.onError(error);
+                    }
+                },
+                onRequestEnd: () => {
+                    fetchConfigs.handlers.onRequestEnd?.({
+                        showLoading: options?.showLoading || false,
+                    });
+                },
+                onRequestStart: () => {
+                    fetchConfigs.handlers.onRequestStart?.({
+                        showLoading: options?.showLoading || false,
+                    });
+                },
+                onRequestPrepare: (input) => {
+                    const defaultValues = {
+                        body: input.body,
+                        globalParameters: input.globalParameters,
+                        headers: input.headers,
+                    };
+                    return (fetchConfigs.handlers.onRequestPrepare?.(defaultValues) ||
+                        defaultValues);
+                },
+            },
+            headers: fetchConfigs.configs.headers || {},
+            method,
+            signal: combinedSignal,
+            staticResponse,
+            url: `${fetchConfigs.configs.baseUrl}/${path}`,
+        });
+    };
+    const handleOnSuccess = (type, { data, dataUpdatedAt, isSuccess, }, { inputData }) => {
+        // console.log(`[DEBUG] useFetchCore :: ${path} :: handleOnSuccess check if is to call`, {
+        // 	data,
+        // 	isSuccess,
+        // });
+        // only call onSuccess if dataUpdatedAt is newer than last call (to avoid double calls)
+        if (((type === 'query' && lastDataUpdatedAt.current < (dataUpdatedAt || 0)) ||
+            type === 'mutation') &&
+            isSuccess &&
+            onSuccess) {
+            // console.log(`[DEBUG] useFetchCore :: ${path} :: handleOnSuccess called`, {
+            // 	data,
+            // 	isSuccess,
+            // });
+            lastDataUpdatedAt.current = dataUpdatedAt || 0;
+            onSuccess(data, { inputData });
+        }
+    };
+    const handleGetCommonFetchResponse = ({ data, error, isError, isPending, isSuccess, status, }) => {
+        return {
+            cancel: () => {
+                if (fetchSignal.current) {
+                    fetchSignal.current.abort('user_cancelled');
+                }
+            },
+            data: data?.data,
+            error,
+            isError,
+            isPending,
+            isSuccess,
+            response: data,
+            status,
+        };
+    };
+    return {
+        getBaseReactQueryInput: handleGetBaseReactQueryInput,
+        getCommonFetchResponse: handleGetCommonFetchResponse,
+        getFetchTreatment: handleGetFetchTreatment,
+        getLastResponseKey: () => [`${key}::lastResponse`],
+        onSuccess: handleOnSuccess,
+    };
+};
+exports.useFetchCore = useFetchCore;

package/dist/cjs/useFetchMutation.js

@@ -1,19 +1,52 @@
 "use strict";
+'use client';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFetchMutation = void 0;
-const useFetch_1 = require("./useFetch");
-const useFetchMutation = (input) => {
-    const ret = (0, useFetch_1.useFetch)(input);
-    const transformedRet = {
-        abort: ret.abort,
-        data$: ret.data$,
-        error$: ret.error$,
-        isFetching$: ret.isFetching$,
-        mutate: ret.fetch,
-        response$: ret.response$,
-        status$: ret.status$,
+const react_query_1 = require("@tanstack/react-query");
+const useFetchCore_1 = require("./useFetchCore");
+/**
+ * Custom React hook for performing mutations using React Query and a fetch-based treatment.
+ *
+ * @template TInput - The type of the mutation input.
+ * @template TOutput - The type of the mutation output, extending `TFetchDefaultOutput`.
+ * @template TTransformOutput - The type of the transformed mutation output, extending `TFetchDefaultOutput`. Defaults to `TOutput`.
+ *
+ * @param props - The input properties for configuring the mutation, including fetch logic and success handling.
+ * @returns An object containing the common fetch response, mutation functions (`mutate`, `mutateAsync`), and additional mutation state.
+ *
+ * @remarks
+ * - Uses `useMutation` from React Query to handle mutation logic.
+ * - Integrates with custom fetch treatment and response transformation.
+ * - Calls `onSuccess` callback when the mutation succeeds.
+ */
+const useFetchMutation = (props) => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { getBaseReactQueryInput, getCommonFetchResponse, getFetchTreatment, getLastResponseKey, onSuccess, } = (0, useFetchCore_1.useFetchCore)(props);
+    const res = (0, react_query_1.useMutation)({
+        ...getBaseReactQueryInput(),
+        mutationFn: async (body) => {
+            return getFetchTreatment({ body });
+        },
+        onSuccess: (data, variables) => {
+            queryClient.setQueryData(getLastResponseKey(), data);
+            onSuccess('mutation', { data, isSuccess: true }, { inputData: variables });
+        },
+    });
+    return {
+        ...getCommonFetchResponse(res),
+        getLastResponse: () => {
+            const response = queryClient.getQueryData(getLastResponseKey());
+            return {
+                data: response?.data,
+                response,
+            };
+        },
+        mutate: (data) => {
+            return res.mutate(data);
+        },
+        mutateAsync: (data) => {
+            return res.mutateAsync(data);
+        },
     };
-    return transformedRet;
 };
 exports.useFetchMutation = useFetchMutation;
-//# sourceMappingURL=useFetchMutation.js.map

package/dist/cjs/useFetchQuery.js

@@ -1,18 +1,40 @@
 "use strict";
+'use client';
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFetchQuery = void 0;
-const merge_1 = require("@react-xp/merge");
-const fetchHelper_1 = require("./fetchHelper");
-const useFetch_1 = require("./useFetch");
-const useFetchQuery = (input) => {
-    const deepMerge = (0, merge_1.useDeepMerge)();
-    const configs = fetchHelper_1.fetchHelper.configs();
-    return (0, useFetch_1.useFetch)(deepMerge(input, {
-        options: {
-            callOnMount: true,
-            cache: input.options?.cache || configs.options?.cache,
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const useFetchCore_1 = require("./useFetchCore");
+/**
+ * Custom React hook for fetching data using React Query with enhanced configuration and response handling.
+ *
+ * @template TInput - The type of the input parameters for the fetch query.
+ * @template TOutput - The type of the output returned by the fetch query. Must extend `TFetchDefaultOutput`.
+ * @template TTransformOutput - The type of the transformed output returned by the query function. Defaults to `TOutput`.
+ *
+ * @param props - The input properties required to configure the fetch query, including query parameters and transformation logic.
+ * @returns An object containing the common fetch response, including data, status, error, and a `refetch` function.
+ *
+ * @remarks
+ * - Utilizes `useFetchCore` for shared fetch logic and configuration.
+ * - Wraps the query function with React Query's `useQuery` for caching and state management.
+ * - Executes the `onSuccess` callback whenever the query result changes.
+ * - The returned object merges the common fetch response with the `refetch` method from React Query.
+ */
+const useFetchQuery = (props) => {
+    const { getBaseReactQueryInput, getCommonFetchResponse, getFetchTreatment, onSuccess, } = (0, useFetchCore_1.useFetchCore)(props);
+    const res = (0, react_query_1.useQuery)({
+        ...getBaseReactQueryInput(),
+        queryFn: async ({ signal }) => {
+            return getFetchTreatment({ signal });
         },
-    }));
+    });
+    (0, react_1.useEffect)(() => {
+        onSuccess('query', res, { inputData: props.data });
+    }, [onSuccess, res, props.data]);
+    return {
+        ...getCommonFetchResponse(res),
+        refetch: res.refetch,
+    };
 };
 exports.useFetchQuery = useFetchQuery;
-//# sourceMappingURL=useFetchQuery.js.map

package/dist/cjs/useFetchUtils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFetchUtils = void 0;
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const fetchContext_1 = require("./fetchContext");
+/**
+ * Custom hook providing utility functions for managing fetch queries and global parameters.
+ *
+ * @returns An object containing:
+ * - `cancelQueries`: Cancels ongoing queries for the specified keys, or all queries if no keys are provided.
+ * - `clearCache`: Clears the cache for the specified keys, or clears all cache if no keys are provided.
+ * - `setGlobalParameters`: Sets global parameters for fetch operations.
+ *
+ * @remarks
+ * This hook leverages the query client and fetch context to provide centralized query management utilities.
+ */
+const useFetchUtils = () => {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    const { setGlobalParameters } = (0, react_1.useContext)(fetchContext_1.fetchContext);
+    return (0, react_1.useMemo)(() => ({
+        cancelQueries: (keys = undefined) => {
+            if (!keys || keys.length === 0) {
+                queryClient.cancelQueries();
+            }
+            else {
+                for (const key of keys) {
+                    queryClient.cancelQueries({ queryKey: key });
+                }
+            }
+        },
+        clearCache: (keys = undefined) => {
+            if (!keys || keys.length === 0) {
+                queryClient.invalidateQueries();
+            }
+            else {
+                for (const key of keys) {
+                    queryClient.invalidateQueries({ queryKey: key });
+                }
+            }
+        },
+        setGlobalParameters,
+    }), [queryClient, setGlobalParameters]);
+};
+exports.useFetchUtils = useFetchUtils;

package/dist/esm/fetchContext.js

@@ -0,0 +1,23 @@
+'use client';
+import { createContext } from 'react';
+/**
+ * React context for managing fetch configurations and global parameters.
+ *
+ * @remarks
+ * This context provides default values for fetch configurations, a method to retrieve namespace-specific configs,
+ * an initialization flag, and a setter for global parameters.
+ *
+ * @property {Object} configs - Global fetch configurations.
+ * @property {Function} getNamespaceConfig - Returns configuration and handlers for a specific namespace.
+ * @property {boolean} isInitialized - Indicates if the context has been initialized.
+ * @property {Function} setGlobalParameters - Sets global parameters for fetch operations.
+ */
+export const fetchContext = createContext({
+    configs: {},
+    getNamespaceConfig: () => ({
+        configs: { baseUrl: 'http://localhost:3000', cache: {} },
+        handlers: { onError: () => { } },
+    }),
+    isInitialized: false,
+    setGlobalParameters: () => { },
+});

package/dist/esm/fetchCore.js

@@ -0,0 +1,54 @@
+import { transformTemplateString } from '@react-xp/utils';
+export const fetchCore = async ({ data, globalParameters, handlers, headers, method, signal, staticResponse, url, }) => {
+    const handleOnError = async (error) => {
+        // ignore parsing error caused by abort
+        if (error === 'user_cancelled' || error?.name === 'AbortError') {
+            return {};
+        }
+        handlers?.onError?.(error, null);
+        throw error;
+    };
+    try {
+        handlers?.onRequestStart?.();
+        const defaultValues = {
+            body: data,
+            globalParameters: globalParameters || {},
+            headers: headers || {},
+        };
+        const { body: preparedBody, headers: preparedHeaders } = handlers?.onRequestPrepare?.(defaultValues) || defaultValues;
+        const masterUrl = url.replace(/\/+/g, '/').replace(':/', '://');
+        const transformedUrl = transformTemplateString({
+            template: masterUrl,
+            values: {
+                ...defaultValues.globalParameters,
+                ...preparedBody,
+            },
+        });
+        let res;
+        if (staticResponse) {
+            res = await staticResponse();
+        }
+        else {
+            const response = await fetch(transformedUrl.value, {
+                method,
+                headers: preparedHeaders,
+                body: preparedBody ? JSON.stringify(preparedBody) : undefined,
+                signal,
+            });
+            if (!response.ok) {
+                return handleOnError(response);
+            }
+            res = await response.json();
+        }
+        if (res.metadata?.status?.toLowerCase() === 'error') {
+            return handleOnError(res);
+        }
+        return res;
+    }
+    catch (error) {
+        return handleOnError(error);
+    }
+    finally {
+        handlers?.onRequestEnd?.();
+    }
+};