@pagamio/frontend-commons-lib 0.8.175 → 0.8.183

package/lib/shared/utils/filterUtils.js

@@ -0,0 +1,31 @@
+export const isDefaultFilterValue = (value, key) => {
+    // Special case for dateRangeType
+    if (key === 'dateRangeType' && (value === '' || value === 'ALL_TIME')) {
+        return true;
+    }
+    if (!value)
+        return true;
+    if (Array.isArray(value) && value.length === 0)
+        return true;
+    if (typeof value === 'string' && (value === '' || value === 'all' || value.toLowerCase() === 'all'))
+        return true;
+    return false;
+};
+export const hasFilterChanges = (selectedFilters, appliedFilters) => {
+    return JSON.stringify(selectedFilters) !== JSON.stringify(appliedFilters);
+};
+export const hasSelectedFilterChanges = (selectedFilters, appliedFilters) => {
+    const normalizedSelected = Object.entries(selectedFilters)
+        .filter(([key, value]) => !isDefaultFilterValue(value, key))
+        .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    const normalizedApplied = Object.entries(appliedFilters)
+        .filter(([key, value]) => !isDefaultFilterValue(value, key))
+        .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    return JSON.stringify(normalizedSelected) !== JSON.stringify(normalizedApplied);
+};
+export const hasActiveFilters = (filters) => {
+    return Object.entries(filters).some(([key, value]) => !isDefaultFilterValue(value, key));
+};
+export const hasAppliedFilters = (filters) => {
+    return Object.entries(filters).some(([key, value]) => !isDefaultFilterValue(value, key));
+};

package/lib/shared/utils/functionHelper.d.ts

@@ -0,0 +1,27 @@
+import type { SpringBootResponse } from 'src/api';
+import type { QueryConfigProps } from '../types';
+export declare const createQueryConfig: (startDate: string | undefined, endDate: string | undefined, options: Partial<QueryConfigProps>, filters?: {
+    [key: string]: string | string[] | null;
+}) => QueryConfigProps;
+/**
+ * Helper function to get nested object value by path
+ */
+export declare const getNestedValue: (obj: any, path: string) => any;
+/**
+ * Converts a simple array to a SpringBoot response format
+ *
+ * @param {T[]} response - The array to convert into SpringBoot response format
+ * @returns {SpringBootResponse<T>} A SpringBoot paginated response object with the array as content
+ * @template T - The type of items in the array
+ */
+export declare function arrayToSpringBootResponse<T>(response: T[]): SpringBootResponse<T>;
+/**
+ * Generates a cryptographically secure random string
+ * @param length - The length of the random string to generate (default: 6)
+ * @returns A secure random string
+ */
+export declare const generateSecureRandomString: (length?: number) => string;
+/**
+ * Uploads a file to a presigned URL using XMLHttpRequest
+ */
+export declare function uploadFileWithXHR(url: string, file: File): Promise<void>;

package/lib/shared/utils/functionHelper.js

@@ -0,0 +1,124 @@
+export const createQueryConfig = (startDate, endDate, options, filters) => {
+    return {
+        startDate,
+        endDate,
+        filters,
+        metrics: options.metrics ?? [],
+        aggregationType: options.aggregationType ?? 'SUM',
+        dimensions: options.dimensions,
+        limit: options.limit,
+        sortBy: options.sortBy,
+        sortDirection: options.sortDirection,
+        page: options.page,
+        size: options.size,
+    };
+};
+/**
+ * Helper function to get nested object value by path
+ */
+export const getNestedValue = (obj, path) => {
+    return path.split('.').reduce((acc, part) => acc?.[part], obj);
+};
+/**
+ * Converts a simple array to a SpringBoot response format
+ *
+ * @param {T[]} response - The array to convert into SpringBoot response format
+ * @returns {SpringBootResponse<T>} A SpringBoot paginated response object with the array as content
+ * @template T - The type of items in the array
+ */
+export function arrayToSpringBootResponse(response) {
+    return {
+        content: response,
+        empty: response.length === 0,
+        first: true,
+        last: true,
+        number: 0,
+        numberOfElements: response.length,
+        pageable: {
+            sort: {
+                empty: true,
+                sorted: false,
+                unsorted: true,
+            },
+            offset: 0,
+            pageNumber: 0,
+            pageSize: response.length,
+            paged: false,
+            unpaged: true,
+        },
+        size: response.length,
+        sort: {
+            empty: true,
+            sorted: false,
+            unsorted: true,
+        },
+        totalElements: response.length,
+        totalPages: 1,
+    };
+}
+/**
+ * Generates a cryptographically secure random string
+ * @param length - The length of the random string to generate (default: 6)
+ * @returns A secure random string
+ */
+export const generateSecureRandomString = (length = 6) => {
+    if (typeof window !== 'undefined' && window.crypto?.getRandomValues) {
+        const array = new Uint8Array(length);
+        window.crypto.getRandomValues(array);
+        return Array.from(array, (byte) => byte.toString(36))
+            .join('')
+            .substring(0, length);
+    }
+    // Node.js environment
+    if (typeof require !== 'undefined') {
+        try {
+            const crypto = require('crypto');
+            return crypto.randomBytes(length).toString('hex').substring(0, length);
+        }
+        catch (error) {
+            // If crypto module is not available, fall back to timestamp + counter
+            console.warn('Crypto module not available, using timestamp-based fallback');
+            console.error('Error while generating secure random string:', error);
+            const timestamp = Date.now().toString(36);
+            const counter = (typeof performance !== 'undefined' ? performance.now() : Date.now()).toString(36);
+            return (timestamp + counter).substring(0, length);
+        }
+    }
+    //timestamp with counter
+    const timestamp = Date.now().toString(36);
+    const counter = (performance?.now() || Date.now()).toString(36);
+    return (timestamp + counter).substring(0, length);
+};
+/**
+ * Uploads a file to a presigned URL using XMLHttpRequest
+ */
+export function uploadFileWithXHR(url, file) {
+    return new Promise((resolve, reject) => {
+        let acl = null;
+        try {
+            const parsed = new URL(url);
+            acl = parsed.searchParams.get('x-amz-acl');
+        }
+        catch { }
+        const xhr = new XMLHttpRequest();
+        xhr.open('PUT', url, true);
+        xhr.responseType = 'text';
+        xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Upload failed: ${xhr.status} ${xhr.response?.slice(0, 180)}`));
+            }
+        };
+        xhr.onerror = () => {
+            reject(new Error('Network error during upload'));
+        };
+        const contentType = file.type || 'application/octet-stream';
+        if (contentType)
+            xhr.setRequestHeader('Content-Type', contentType);
+        if (acl)
+            xhr.setRequestHeader('x-amz-acl', acl);
+        xhr.send(file);
+    });
+}

package/lib/shared/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './localStorage';
+export * from './functionHelper';

package/lib/shared/utils/index.js

@@ -0,0 +1,2 @@
+export * from './localStorage';
+export * from './functionHelper';

package/lib/shared/utils/localStorage.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Type-safe local storage utility functions
+ * Provides methods for managing data in localStorage with proper error handling
+ */
+/**
+ * Interface for key-value pair storage operations
+ */
+interface StorageItem {
+    key: string;
+    value: unknown;
+}
+/**
+ * Gets an item from localStorage with type safety
+ * @param key - Storage key
+ * @returns Parsed value or null if not found
+ */
+export declare function getLocalStorageItem<T>(key: string): T | null;
+/**
+ * Sets multiple items in localStorage
+ * @param items - Array of key-value pairs to store
+ */
+export declare function setLocalStorageItems(items: StorageItem[]): void;
+/**
+ * Removes multiple items from localStorage
+ * @param keys - Array of keys to remove
+ */
+export declare function removeLocalStorageItems(keys: string[]): void;
+/**
+ * Clears all items from localStorage
+ */
+export declare function clearLocalStorage(): void;
+/**
+ * Gets the size of localStorage in bytes
+ * @returns Size in bytes or 0 if not available
+ */
+export declare function getLocalStorageSize(): number;
+/**
+ * Checks if localStorage is available
+ * @returns boolean indicating if localStorage is available
+ */
+export declare function isLocalStorageAvailable(): boolean;
+/**
+ * Gets all keys in localStorage
+ * @returns Array of localStorage keys
+ */
+export declare function getLocalStorageKeys(): string[];
+/**
+ * Checks if a key exists in localStorage
+ * @param key - Key to check
+ * @returns boolean indicating if key exists
+ */
+export declare function hasLocalStorageItem(key: string): boolean;
+export {};

package/lib/shared/utils/localStorage.js

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Type-safe local storage utility functions
+ * Provides methods for managing data in localStorage with proper error handling
+ */
+/**
+ * Gets an item from localStorage with type safety
+ * @param key - Storage key
+ * @returns Parsed value or null if not found
+ */
+export function getLocalStorageItem(key) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const item = localStorage.getItem(key);
+        if (!item)
+            return null;
+        return JSON.parse(item);
+    }
+    catch (error) {
+        console.error(`Error getting localStorage item ${key}:`, error);
+        return null;
+    }
+}
+/**
+ * Sets multiple items in localStorage
+ * @param items - Array of key-value pairs to store
+ */
+export function setLocalStorageItems(items) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        items.forEach(({ key, value }) => {
+            localStorage.setItem(key, typeof value === 'string' ? value : JSON.stringify(value));
+        });
+    }
+    catch (error) {
+        console.error('Error setting localStorage items:', error);
+    }
+}
+/**
+ * Removes multiple items from localStorage
+ * @param keys - Array of keys to remove
+ */
+export function removeLocalStorageItems(keys) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        keys.forEach((key) => localStorage.removeItem(key));
+    }
+    catch (error) {
+        console.error('Error removing localStorage items:', error);
+    }
+}
+/**
+ * Clears all items from localStorage
+ */
+export function clearLocalStorage() {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        localStorage.clear();
+    }
+    catch (error) {
+        console.error('Error clearing localStorage:', error);
+    }
+}
+/**
+ * Gets the size of localStorage in bytes
+ * @returns Size in bytes or 0 if not available
+ */
+export function getLocalStorageSize() {
+    if (typeof window === 'undefined')
+        return 0;
+    try {
+        let total = 0;
+        for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            if (key) {
+                const value = localStorage.getItem(key);
+                if (value) {
+                    total += key.length + value.length;
+                }
+            }
+        }
+        return total * 2; // Multiply by 2 since characters are 2 bytes each
+    }
+    catch (error) {
+        console.error('Error calculating localStorage size:', error);
+        return 0;
+    }
+}
+/**
+ * Checks if localStorage is available
+ * @returns boolean indicating if localStorage is available
+ */
+export function isLocalStorageAvailable() {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        const testKey = '__storage_test__';
+        localStorage.setItem(testKey, testKey);
+        localStorage.removeItem(testKey);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Gets all keys in localStorage
+ * @returns Array of localStorage keys
+ */
+export function getLocalStorageKeys() {
+    if (typeof window === 'undefined')
+        return [];
+    try {
+        return Object.keys(localStorage);
+    }
+    catch (error) {
+        console.error('Error getting localStorage keys:', error);
+        return [];
+    }
+}
+/**
+ * Checks if a key exists in localStorage
+ * @param key - Key to check
+ * @returns boolean indicating if key exists
+ */
+export function hasLocalStorageItem(key) {
+    if (typeof window === 'undefined')
+        return false;
+    try {
+        return key in localStorage;
+    }
+    catch (error) {
+        console.error(`Error checking localStorage for key ${key}:`, error);
+        return false;
+    }
+}