@hichchi/ngx-utils 0.0.1-alpha.1 → 0.0.1-alpha.2

package/fesm2022/hichchi-ngx-utils.mjs

@@ -1,115 +1,503 @@
-import * as i0 from '@angular/core';
-import { inject, Injectable, computed } from '@angular/core';
-import { signalStore, withState, withComputed, withMethods, patchState } from '@ngrx/signals';
-import { withStorageSync } from '@angular-architects/ngrx-toolkit';
-import { take, map, tap, catchError, EMPTY, ReplaySubject, throwError, switchMap, filter } from 'rxjs';
-import { HttpClient } from '@angular/common/http';
-import { AuthEndpoint, AuthErrorResponseCode } from '@hichchi/nest-connector/auth';
-import { Endpoint, HttpClientErrorStatus } from '@hichchi/nest-connector';
-import { Router } from '@angular/router';
+import { FormGroup, FormArray } from '@angular/forms';
 
 // noinspection JSUnusedGlobalSymbols
-class AuthService {
-    http = inject(HttpClient);
-    signIn(dto) {
-        return this.http.post(`${Endpoint.AUTH}/${AuthEndpoint.SIGN_IN}`, dto).pipe(take(1), map(res => ({
-            ...res,
-            accessTokenExpiresOn: new Date(res.accessTokenExpiresOn),
-            refreshTokenExpiresOn: new Date(res.accessTokenExpiresOn),
-        })));
-    }
-    authenticateSocial(accessToken) {
-        return this.http
-            .post(`${Endpoint.AUTH}/${AuthEndpoint.AUTHENTICATE_SOCIAL}`, {
-            accessToken,
-        })
-            .pipe(take(1), map(res => ({
-            ...res,
-            accessTokenExpiresOn: new Date(res.accessTokenExpiresOn),
-            refreshTokenExpiresOn: new Date(res.accessTokenExpiresOn),
-        })));
-    }
-    signUp(dto) {
-        return this.http.post(`${Endpoint.AUTH}/${AuthEndpoint.SIGN_UP}`, dto).pipe(take(1));
-    }
-    refreshToken(refreshToken) {
-        return this.http
-            .post(`${Endpoint.AUTH}/${AuthEndpoint.REFRESH_TOKEN}`, {
-            refreshToken,
-        })
-            .pipe(take(1));
-    }
-    signOut() {
-        // this.app.startSpinner();
-        return this.http.post(`${Endpoint.AUTH}/${AuthEndpoint.SIGN_OUT}`, {}).pipe(take(1));
+/**
+ * Recursively marks invalid form controls as dirty and touched
+ *
+ * This utility function traverses a form hierarchy and marks all invalid controls
+ * as dirty and touched, which triggers validation error display in the UI. It works
+ * recursively through nested FormGroups and FormArrays to ensure all invalid
+ * controls are properly marked for error display.
+ *
+ * The function is particularly useful when you want to show all validation errors
+ * at once, such as when a user attempts to submit a form. It only marks invalid
+ * controls, leaving valid controls unchanged.
+ *
+ * Key features:
+ * - Recursive traversal of form hierarchy
+ * - Only marks invalid controls as dirty/touched
+ * - Handles nested FormGroups and FormArrays
+ * - Updates validation state after marking controls
+ * - Non-destructive (doesn't affect valid controls)
+ *
+ * @param form - The FormGroup to process recursively
+ *
+ * @example
+ * ```typescript
+ * // Mark all invalid controls in a form for error display
+ * export class UserFormComponent {
+ *   userForm = this.fb.group({
+ *     name: ['', Validators.required],
+ *     email: ['', [Validators.required, Validators.email]],
+ *     address: this.fb.group({
+ *       street: ['', Validators.required],
+ *       city: ['', Validators.required]
+ *     })
+ *   });
+ *
+ *   onSubmit() {
+ *     if (this.userForm.invalid) {
+ *       // Mark all invalid fields to show errors
+ *       markFormDirty(this.userForm);
+ *       return;
+ *     }
+ *     // Process valid form...
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with form arrays
+ * export class DynamicFormComponent {
+ *   form = this.fb.group({
+ *     items: this.fb.array([
+ *       this.fb.group({
+ *         name: ['', Validators.required],
+ *         quantity: [0, Validators.min(1)]
+ *       })
+ *     ])
+ *   });
+ *
+ *   validateAll() {
+ *     markFormDirty(this.form);
+ *     // All invalid controls in the array will be marked
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link FormGroup} Angular reactive form group
+ * @see {@link FormArray} Angular reactive form array
+ * @see {@link validatedFormData} Function that uses this utility for validation
+ */
+function markFormDirty(form) {
+    const markDirty = (form) => {
+        Object.keys(form.controls).forEach(field => {
+            const control = form.get(field);
+            if (control?.invalid) {
+                control?.markAsDirty({ onlySelf: true });
+                control?.markAsTouched({ onlySelf: true });
+                control.updateValueAndValidity({ onlySelf: true });
+            }
+            if (control instanceof FormGroup) {
+                markDirty(control);
+            }
+            if (control instanceof FormArray) {
+                control.controls.forEach((control) => {
+                    markDirty(control);
+                });
+            }
+        });
+    };
+    return markDirty(form);
+}
+/**
+ * Removes null values from an object by deleting properties with null values
+ *
+ * This utility function creates a new object with all null properties removed.
+ * It's particularly useful when working with form data where null values should
+ * be omitted from API requests or when preparing data for processing that doesn't
+ * handle null values well.
+ *
+ * The function performs a shallow copy of the object and removes any properties
+ * that have null values. Properties with undefined values are preserved, as they
+ * represent different semantic meaning (missing vs explicitly null).
+ *
+ * @template T - The type of the object being processed
+ * @param obj - Object that may contain null values to be removed
+ * @returns A new object with null properties removed
+ *
+ * @example
+ * ```typescript
+ * // Remove null values from form data
+ * const formData = {
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   phone: null,
+ *   address: null,
+ *   age: 30
+ * };
+ *
+ * const cleanData = replaceNulls(formData);
+ * // Result: { name: 'John Doe', email: 'john@example.com', age: 30 }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with API request data
+ * interface UserUpdate {
+ *   name?: string | null;
+ *   email?: string | null;
+ *   phone?: string | null;
+ * }
+ *
+ * const updateData: UserUpdate = {
+ *   name: 'Jane Smith',
+ *   email: null, // Don't update email
+ *   phone: '555-1234'
+ * };
+ *
+ * const apiPayload = replaceNulls(updateData);
+ * // Result: { name: 'Jane Smith', phone: '555-1234' }
+ * // API receives only the fields to update
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Difference between null and undefined
+ * const data = {
+ *   field1: 'value',
+ *   field2: null,      // Will be removed
+ *   field3: undefined  // Will be preserved
+ * };
+ *
+ * const result = replaceNulls(data);
+ * // Result: { field1: 'value', field3: undefined }
+ * ```
+ *
+ * @see {@link validatedFormData} Function that uses this utility to clean form data
+ */
+function replaceNulls(obj) {
+    const result = { ...obj };
+    for (const key in result) {
+        if (result[key] === null) {
+            delete result[key];
+        }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AuthService, providedIn: "root" });
+    return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.7", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: "root",
-                }]
-        }] });
-
-/* eslint-disable */
-// noinspection JSUnusedGlobalSymbols
-const initialState = {
-    signedIn: false,
-    sessionId: null,
-    user: null,
-    accessToken: null,
-    refreshToken: null,
-    accessTokenExpiresOn: null,
-    refreshTokenExpiresOn: null,
-};
-const AuthState = signalStore({ providedIn: "root" }, withState(initialState), withStorageSync({ key: "auth" }), withComputed(({ accessToken, user }) => ({
-    hasAccessToken: computed(() => Boolean(accessToken())),
-    role: computed(() => user()?.role),
-    emailVerified: computed(() => Boolean(user()?.emailVerified)),
-})), withMethods((store, router = inject(Router), authService = inject(AuthService)) => ({
-    reset() {
-        patchState(store, initialState);
-    },
-    setTokens(tokenResponse) {
-        const { accessToken, refreshToken, accessTokenExpiresOn, refreshTokenExpiresOn } = tokenResponse;
-        patchState(store, state => ({
-            ...state,
-            accessToken,
-            refreshToken,
-            accessTokenExpiresOn,
-            refreshTokenExpiresOn,
-        }));
-    },
-    signIn(signInBody, redirect) {
-        return authService.signIn(signInBody).pipe(tap((res) => {
-            patchState(store, { ...res, signedIn: true });
-            void router.navigateByUrl(typeof redirect === "string" ? redirect : redirect(res));
-        }));
-    },
-    authenticateSocial: (accessToken, redirect) => {
-        return authService.authenticateSocial(accessToken).pipe(tap((res) => {
-            patchState(store, { ...res, signedIn: Boolean(res.user.role) });
-            void router.navigateByUrl(typeof redirect === "string" ? redirect : redirect(res));
-        }), catchError(() => EMPTY));
-    },
-    signOut: (redirect) => {
-        return authService.signOut().pipe(tap({
-            next: () => {
-                patchState(store, initialState);
-                void router.navigateByUrl(redirect);
-            },
-        }), catchError(() => EMPTY));
-    },
-})));
-
-// noinspection JSUnusedGlobalSymbols
-function utils() {
-    return "Hello World";
+/**
+ * Validates a form and returns clean data if valid, or null if invalid
+ *
+ * This utility function combines form validation with data cleaning in a single operation.
+ * It first marks all invalid controls as dirty (to show validation errors), then checks
+ * if the form is valid. If valid, it returns the form data with null values removed.
+ * If invalid, it returns null.
+ *
+ * This is particularly useful for form submission handlers where you want to:
+ * 1. Show all validation errors if the form is invalid
+ * 2. Get clean, validated data if the form is valid
+ * 3. Handle both cases with a simple null check
+ *
+ * The function uses the DataFormGroup type to ensure type safety between the form
+ * structure and the returned data type.
+ *
+ * @template T - The type of the data structure represented by the form
+ * @param form - The DataFormGroup to validate and extract data from
+ * @returns The validated and cleaned form data, or null if the form is invalid
+ *
+ * @example
+ * ```typescript
+ * // Basic form validation and submission
+ * export class UserFormComponent {
+ *   userForm: DataFormGroup<UserData> = this.fb.group({
+ *     name: ['', Validators.required],
+ *     email: ['', [Validators.required, Validators.email]],
+ *     phone: [null], // Optional field
+ *     age: [null, Validators.min(18)]
+ *   });
+ *
+ *   onSubmit() {
+ *     const validData = validatedFormData(this.userForm);
+ *     if (validData) {
+ *       // Form is valid, submit clean data
+ *       this.userService.createUser(validData);
+ *     } else {
+ *       // Form is invalid, errors are now visible
+ *       console.log('Please fix form errors');
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with async operations
+ * export class ProfileComponent {
+ *   profileForm: DataFormGroup<ProfileUpdate> = this.fb.group({
+ *     firstName: ['', Validators.required],
+ *     lastName: ['', Validators.required],
+ *     bio: [null], // Optional
+ *     website: [null, Validators.pattern(/^https?:\/\/.+/)]
+ *   });
+ *
+ *   async updateProfile() {
+ *     const updateData = validatedFormData(this.profileForm);
+ *     if (!updateData) {
+ *       this.showErrorMessage('Please fix the form errors');
+ *       return;
+ *     }
+ *
+ *     try {
+ *       await this.profileService.update(updateData);
+ *       this.showSuccessMessage('Profile updated successfully');
+ *     } catch (error) {
+ *       this.showErrorMessage('Failed to update profile');
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Type-safe form data extraction
+ * interface ContactForm {
+ *   name: string;
+ *   email: string;
+ *   message: string;
+ *   newsletter?: boolean;
+ * }
+ *
+ * const contactForm: DataFormGroup<ContactForm> = this.fb.group({
+ *   name: ['', Validators.required],
+ *   email: ['', [Validators.required, Validators.email]],
+ *   message: ['', [Validators.required, Validators.minLength(10)]],
+ *   newsletter: [null]
+ * });
+ *
+ * const formData = validatedFormData(contactForm);
+ * if (formData) {
+ *   // TypeScript knows formData is ContactForm with null values removed
+ *   console.log(formData.name); // string
+ *   console.log(formData.email); // string
+ *   console.log(formData.newsletter); // boolean | undefined (null was removed)
+ * }
+ * ```
+ *
+ * @see {@link DataFormGroup} Type-safe form group interface
+ * @see {@link markFormDirty} Function used internally to mark invalid controls
+ * @see {@link replaceNulls} Function used internally to clean the data
+ */
+function validatedFormData(form) {
+    markFormDirty(form);
+    if (form.invalid)
+        return null;
+    return replaceNulls(form.value);
+}
+/**
+ * Creates a FormData object from a plain JavaScript object
+ *
+ * This utility function converts a plain object into a FormData object, which is
+ * required for multipart/form-data HTTP requests, particularly when uploading files
+ * or sending form data that includes binary content. The function handles different
+ * data types appropriately, preserving file names for File objects and converting
+ * other values to strings.
+ *
+ * The function is particularly useful when working with Angular forms that need to
+ * submit both regular form fields and file uploads in a single request. It automatically
+ * handles the conversion of various data types to the format expected by FormData.
+ *
+ * Key features:
+ * - Preserves original file names for File objects
+ * - Converts primitive values to strings
+ * - Maintains type safety with generic constraints
+ * - Handles Blob objects correctly
+ * - Creates multipart/form-data compatible output
+ *
+ * @template T - Object type with string keys and values that can be converted to FormData
+ * @param data - Object containing the data to convert to FormData
+ * @returns A FormData object ready for HTTP submission
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with mixed data types
+ * const formData = createFormData({
+ *   name: 'John Doe',
+ *   age: 30,
+ *   isActive: true,
+ *   avatar: fileInput.files[0] // File object
+ * });
+ *
+ * // Submit via HTTP
+ * this.http.post('/api/users', formData).subscribe();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // File upload with metadata
+ * export class FileUploadComponent {
+ *   onFileUpload(file: File, description: string, isPublic: boolean) {
+ *     const uploadData = createFormData({
+ *       file: file,
+ *       description: description,
+ *       isPublic: isPublic,
+ *       uploadedAt: new Date().toISOString()
+ *     });
+ *
+ *     this.fileService.upload(uploadData).subscribe({
+ *       next: (response) => console.log('Upload successful'),
+ *       error: (error) => console.error('Upload failed', error)
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with form validation
+ * export class ProfileFormComponent {
+ *   profileForm = this.fb.group({
+ *     name: ['', Validators.required],
+ *     bio: [''],
+ *     profilePicture: [null]
+ *   });
+ *
+ *   onSubmit() {
+ *     const formValue = validatedFormData(this.profileForm);
+ *     if (!formValue) return;
+ *
+ *     // Convert to FormData for file upload
+ *     const formData = createFormData({
+ *       name: formValue.name,
+ *       bio: formValue.bio || '',
+ *       profilePicture: formValue.profilePicture,
+ *       timestamp: Date.now()
+ *     });
+ *
+ *     this.profileService.updateProfile(formData);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple file upload
+ * interface UploadRequest {
+ *   title: string;
+ *   category: string;
+ *   document: File;
+ *   thumbnail: File;
+ *   isPrivate: boolean;
+ * }
+ *
+ * const uploadRequest: UploadRequest = {
+ *   title: 'My Document',
+ *   category: 'reports',
+ *   document: documentFile,
+ *   thumbnail: thumbnailFile,
+ *   isPrivate: false
+ * };
+ *
+ * const formData = createFormData(uploadRequest);
+ * // FormData will contain:
+ * // - title: "My Document"
+ * // - category: "reports"
+ * // - document: [File object with original name]
+ * // - thumbnail: [File object with original name]
+ * // - isPrivate: "false"
+ * ```
+ *
+ * @see {@link FormData} Web API interface for form data
+ * @see {@link File} Web API interface for file objects
+ * @see {@link Blob} Web API interface for binary data
+ * @see {@link validatedFormData} Function for getting validated form data to use with this utility
+ */
+function createFormData(data) {
+    const formData = new FormData();
+    Object.entries(data).forEach(([key, value]) => {
+        if (value instanceof File) {
+            formData.append(key, value, value.name);
+        }
+        else {
+            formData.append(key, String(value));
+        }
+    });
+    return formData;
 }
 
 // noinspection JSUnusedGlobalSymbols
+/**
+ * Creates an HTTP interceptor that automatically prepends a base API URL to relative requests
+ *
+ * This interceptor factory function creates an HTTP interceptor that automatically adds a base API URL
+ * to requests that don't already have a complete URL. It's designed to simplify API calls by allowing
+ * developers to use relative URLs throughout their application while ensuring all requests are properly
+ * routed to the correct API base URL.
+ *
+ * The interceptor intelligently handles different URL formats:
+ * - Requests that already start with the provided API base URL are passed through unchanged
+ * - Requests that start with "http" (absolute URLs) are passed through unchanged
+ * - All other requests (relative URLs) have the API base URL prepended
+ *
+ * This is particularly useful in Angular applications where you want to centralize API URL management
+ * and avoid repeating the base URL in every HTTP service call.
+ *
+ * @param apiBase - The base API URL to prepend to relative requests (without trailing slash)
+ * @returns An HttpInterceptorFn that can be used in Angular HTTP interceptor configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic usage in app configuration
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(
+ *       withInterceptors([
+ *         apiUrlInterceptor('https://api.example.com')
+ *       ])
+ *     )
+ *   ]
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with environment configuration
+ * import { environment } from '../environments/environment';
+ *
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideHttpClient(
+ *       withInterceptors([
+ *         apiUrlInterceptor(environment.apiUrl)
+ *       ])
+ *     )
+ *   ]
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In a service, you can now use relative URLs
+ * @Injectable()
+ * export class UserService {
+ *   constructor(private http: HttpClient) {}
+ *
+ *   getUsers() {
+ *     // This will become: https://api.example.com/users
+ *     return this.http.get('users');
+ *   }
+ *
+ *   getUserById(id: string) {
+ *     // This will become: https://api.example.com/users/123
+ *     return this.http.get(`users/${id}`);
+ *   }
+ *
+ *   // Absolute URLs are not modified
+ *   getExternalData() {
+ *     // This remains: https://external-api.com/data
+ *     return this.http.get('https://external-api.com/data');
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In a module-based application
+ * @NgModule({
+ *   providers: [
+ *     {
+ *       provide: HTTP_INTERCEPTORS,
+ *       useValue: apiUrlInterceptor('https://api.myapp.com/v1'),
+ *       multi: true
+ *     }
+ *   ]
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * @see {@link HttpInterceptorFn} Angular HTTP interceptor function type
+ * @see {@link HttpRequest} Angular HTTP request interface
+ */
 function apiUrlInterceptor(apiBase) {
     return (req, next) => {
         if (req.url.startsWith(apiBase) || req.url.startsWith("http")) {
@@ -120,86 +508,18 @@ function apiUrlInterceptor(apiBase) {
     };
 }
 
-const SKIPPED_ERRORS = [
-    AuthErrorResponseCode.AUTH_401_EXPIRED_TOKEN,
-    AuthErrorResponseCode.AUTH_401_INVALID_TOKEN,
-    AuthErrorResponseCode.AUTH_401_NOT_LOGGED_IN,
-];
-let refreshingInProgress = false;
-const isRefreshTokenReq = (req) => req.url.includes(`${Endpoint.AUTH}/${AuthEndpoint.REFRESH_TOKEN}`);
-let tokenSubject = new ReplaySubject(1);
-function authInterceptor(redirect, onRedirect) {
-    return (req, next) => {
-        const authState = inject(AuthState);
-        const authService = inject(AuthService);
-        const router = inject(Router);
-        const setAccessToken = (req, accessToken) => {
-            return req.clone({
-                headers: req.headers.set("Authorization", "Bearer " + accessToken),
-            });
-        };
-        const gotoSignIn = () => {
-            onRedirect?.();
-            authState.reset();
-            // eslint-disable-next-line no-void
-            void router.navigateByUrl(redirect);
-        };
-        const refreshToken = (req, next) => {
-            if (!refreshingInProgress) {
-                refreshingInProgress = true;
-                tokenSubject.next(null);
-                const refreshToken = authState.refreshToken();
-                if (!refreshToken) {
-                    refreshingInProgress = false;
-                    gotoSignIn();
-                    return throwError(() => new Error("Refresh token not found."));
-                }
-                return authService.refreshToken(refreshToken).pipe(switchMap((tokenResponse) => {
-                    authState.setTokens(tokenResponse);
-                    tokenSubject.next(tokenResponse.accessToken);
-                    tokenSubject.complete();
-                    tokenSubject = new ReplaySubject(1);
-                    refreshingInProgress = false;
-                    return next(setAccessToken(req, tokenResponse.accessToken));
-                }), catchError((error) => {
-                    refreshingInProgress = false;
-                    tokenSubject.error(error);
-                    tokenSubject.complete();
-                    tokenSubject = new ReplaySubject(1);
-                    gotoSignIn();
-                    return throwError(() => error);
-                }));
-            }
-            return tokenSubject.pipe(filter(result => result !== null), take(1), switchMap(token => {
-                return next(setAccessToken(req, token));
-            }));
-        };
-        const handleRequest = (req, next) => {
-            return next(req).pipe(catchError((error) => {
-                if (error.status === HttpClientErrorStatus.UNAUTHORIZED &&
-                    error.error?.code &&
-                    SKIPPED_ERRORS.includes(error.error?.code) &&
-                    !isRefreshTokenReq(req)) {
-                    if (authState.signedIn()) {
-                        return refreshToken(req, next);
-                    }
-                }
-                return throwError(() => error);
-            }));
-        };
-        if (authState.accessToken()) {
-            const tokenizedRequest = req.clone({
-                headers: req.headers.set("Authorization", "Bearer " + authState.accessToken()),
-            });
-            return handleRequest(tokenizedRequest, next);
-        }
-        return handleRequest(req, next);
-    };
+// export * from "./response.interceptor";
+
+class HichchiHttpService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
 }
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AuthService, AuthState, SKIPPED_ERRORS, apiUrlInterceptor, authInterceptor, utils };
+export { HichchiHttpService, apiUrlInterceptor, createFormData, markFormDirty, replaceNulls, validatedFormData };
 //# sourceMappingURL=hichchi-ngx-utils.mjs.map