@c-rex/components 0.1.21 → 0.1.23

package/src/generated/create-client-request.tsx

@@ -0,0 +1,105 @@
+/**
+ * Auto-generated from OpenAPI spec (Client-Side)
+ * Source: https://staging.c-rex.net/ids/api/swagger/v1/swagger.json
+ * Generated: 2025-12-11T16:23:03.635Z
+ * Do not edit manually
+ */
+
+"use client";
+
+import { useState, useEffect, useCallback } from 'react';
+import { replacePathParams, call } from "@c-rex/utils"
+
+type SerializedError = {
+    message: string;
+    name: string;
+};
+
+export type DataRequestRenderProps<T> = {
+    data: T | null;
+    error: SerializedError | null;
+    isLoading: boolean;
+};
+
+export type FetchState<T> = {
+    data: T | null;
+    error: Error | null;
+};
+
+export function createClientDataRequest<T, PathParams, QueryParams>(
+    endpointTemplate: string
+) {
+    return function DataRequest(
+        pathParams?: PathParams,
+        queryParams?: QueryParams,
+    ) {
+
+        const [state, setState] = useState<DataRequestRenderProps<T>>({
+            data: null,
+            error: null,
+            isLoading: false,
+        });
+
+        const fetchData = useCallback(async () => {
+            setState({
+                ...state,
+                isLoading: !state.data,
+                error: null,
+            });
+
+            try {
+                const url = replacePathParams(endpointTemplate, pathParams as Record<string, string>);
+                const data = await call<T>("CrexApi.execute", {
+                    url,
+                    method: "get",
+                    params: queryParams as Record<string, string | number | boolean | (string | number | boolean)[] | undefined>,
+                });
+
+                setState({
+                    data,
+                    error: null,
+                    isLoading: false,
+                });
+            } catch (error) {
+                setState({
+                    data: null,
+                    error: error instanceof Error ? error : new Error('Unknown error'),
+                    isLoading: false,
+                });
+            }
+            // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [endpointTemplate, pathParams]);
+
+
+        // Initial fetch
+        useEffect(() => {
+            fetchData();
+        }, [fetchData]);
+
+        return state;
+    };
+}
+
+export type ClientDataRequestProps<T, PathParams, QueryParams> = {
+    pathParams?: PathParams;
+    queryParams?: QueryParams;
+    children: (result: DataRequestRenderProps<T>) => React.ReactNode;
+};
+
+/**
+ * Create a render-prop component for client-side data fetching
+ */
+export function createClientDataRequestComponent<T, PathParams, QueryParams>(
+    endpointTemplate: string
+) {
+    const useDataRequest = createClientDataRequest<T, PathParams, QueryParams>(endpointTemplate);
+
+    return function ClientDataRequest({
+        pathParams,
+        queryParams,
+        children,
+    }: ClientDataRequestProps<T, PathParams, QueryParams>) {
+        const result = useDataRequest(pathParams, queryParams);
+        return <>{children(result)}</>;
+    };
+}

package/src/generated/create-server-request.tsx

@@ -0,0 +1,61 @@
+import { CrexApi } from '@c-rex/core/requests';
+import { OPERATOR_OPTIONS, WILD_CARD_OPTIONS } from '@c-rex/constants';
+
+type SerializedError = {
+    message: string;
+    name: string;
+};
+
+export type DataRequestRenderProps<T> = {
+    data: T;
+    error?: SerializedError;
+};
+
+type DataRequestProps<T, PathParams, QueryParams> = {
+    pathParams?: PathParams;
+    queryParams?: QueryParams;
+    render: (data: T, error?: SerializedError) => React.ReactNode;
+};
+
+
+export function createDataRequestWithParams<T, PathParams, QueryParams>(
+    endpointTemplate: string
+) {
+    return async function DataRequest({
+        pathParams,
+        queryParams = {} as QueryParams,
+        render,
+    }: DataRequestProps<T, PathParams, QueryParams>) {
+        let endpoint = endpointTemplate;
+        if (pathParams) {
+            endpoint = Object.entries(pathParams as Record<string, string>).reduce(
+                (url, [key, value]) => url.replace(`{${key}}`, encodeURIComponent(value)),
+                endpointTemplate
+            );
+        }
+
+        const params = {
+            PageNumber: 1,
+            PageSize: 12,
+            Wildcard: WILD_CARD_OPTIONS.BOTH,
+            QueryOperator: OPERATOR_OPTIONS.OR,
+            ...queryParams,
+        } as Record<string, string | number | boolean | (string | number | boolean)[] | undefined>;
+
+        try {
+            const api = new CrexApi();
+            const data = await api.execute<T>({
+                url: endpoint,
+                method: 'GET',
+                params,
+            });
+            return render(data);
+        } catch (error) {
+            const serializedError: SerializedError = {
+                message: error instanceof Error ? error.message : 'Unknown error',
+                name: error instanceof Error ? error.name : 'Error',
+            };
+            return render({} as T, serializedError);
+        }
+    };
+}

package/src/generated/create-suggestions-request.tsx

@@ -0,0 +1,56 @@
+"use client";
+
+import { AutocompleteSuggestion, SuggestionQueryParams } from '@c-rex/interfaces';
+import { call } from '@c-rex/utils';
+
+type SerializedError = {
+    message: string;
+    name: string;
+};
+
+type SuggestionRequestProps = {
+    prefix: string;
+    queryParams?: SuggestionQueryParams;
+    endpoint: string;
+};
+
+export const suggestionRequest = async ({
+    endpoint,
+    prefix,
+    queryParams = {}
+}: SuggestionRequestProps): Promise<{ data: string[], error?: SerializedError }> => {
+    try {
+        const data = await call<AutocompleteSuggestion>("CrexApi.execute", {
+            url: endpoint,
+            method: "get",
+            params: {
+                Prefix: prefix,
+                ...queryParams
+            },
+        });
+
+        const suggestions: string[] = [];
+        const comparableList: string[] = [];
+
+        if (data.suggestions) {
+            data.suggestions.forEach((item) => {
+                suggestions.push(item.value);
+                comparableList.push(item.value.toLowerCase());
+            });
+        }
+
+        // Add query to beginning if not already in suggestions
+        if (!comparableList.includes(prefix.toLowerCase())) {
+            return { data: [prefix, ...suggestions] };
+        }
+
+        return { data: suggestions };
+
+    } catch (error) {
+        const serializedError: SerializedError = {
+            message: error instanceof Error ? error.message : 'Unknown error',
+            name: error instanceof Error ? error.name : 'Error',
+        };
+        return { data: [], error: serializedError };
+    }
+};