@gaurav_bhandari/common-frontend-services 1.0.0

package/src/services/Storage-Service/localStorageService.ts

@@ -0,0 +1,42 @@
+export class LocalStorageService {
+  private static instance: LocalStorageService;
+
+  private constructor() {}
+
+  public static getInstance(): LocalStorageService {
+    if (!LocalStorageService.instance) {
+      LocalStorageService.instance = new LocalStorageService();
+    }
+    return LocalStorageService.instance;
+  }
+
+  public setItem<T>(key: string, value: T): void {
+    try {
+      const serialized = JSON.stringify(value);
+      localStorage.setItem(key, serialized);
+    } catch (error) {
+      console.error("LocalStorage setItem failed:", error);
+    }
+  }
+
+  public getItem<T>(key: string, defaultValue: T | null = null): T | null {
+    try {
+      const serialized = localStorage.getItem(key);
+      if (!serialized) return defaultValue;
+      return JSON.parse(serialized) as T;
+    } catch (error) {
+      console.error("LocalStorage getItem failed:", error);
+      return defaultValue;
+    }
+  }
+
+  public removeItem(key: string): void {
+    localStorage.removeItem(key);
+  }
+
+  public clear(): void {
+    localStorage.clear();
+  }
+}
+
+export const localStorageService = LocalStorageService.getInstance();

package/src/services/Storage-Service/sessionStorageService.ts

@@ -0,0 +1,42 @@
+export class SessionStorageService {
+  private static instance: SessionStorageService;
+
+  private constructor() {}
+
+  public static getInstance(): SessionStorageService {
+    if (!SessionStorageService.instance) {
+      SessionStorageService.instance = new SessionStorageService();
+    }
+    return SessionStorageService.instance;
+  }
+
+  public setItem<T>(key: string, value: T): void {
+    try {
+      const serialized = JSON.stringify(value);
+      sessionStorage.setItem(key, serialized);
+    } catch (error) {
+      console.error("SessionStorage setItem failed:", error);
+    }
+  }
+
+  public getItem<T>(key: string, defaultValue: T | null = null): T | null {
+    try {
+      const serialized = sessionStorage.getItem(key);
+      if (!serialized) return defaultValue;
+      return JSON.parse(serialized) as T;
+    } catch (error) {
+      console.error("SessionStorage getItem failed:", error);
+      return defaultValue;
+    }
+  }
+
+  public removeItem(key: string): void {
+    sessionStorage.removeItem(key);
+  }
+
+  public clear(): void {
+    sessionStorage.clear();
+  }
+}
+
+export const sessionStorageService = SessionStorageService.getInstance();

package/src/services/Validation-Service/form.ts

@@ -0,0 +1,66 @@
+import type { RuleFn } from "./rules";
+
+export interface FieldConfig<T = any> {
+  rules: RuleFn<T>[];
+  value?: T;
+}
+
+export interface ValidationResult {
+  isValid: boolean;
+  errors: Record<string, string[]>;
+}
+
+export class FormValidator<T extends Record<string, any>> {
+  private schema: Record<keyof T, RuleFn[]>;
+
+  constructor(schema: Record<keyof T, RuleFn[]>) {
+    this.schema = schema;
+  }
+
+  /**
+   * Validate a full data object against the schema
+   */
+  public validate(data: T): ValidationResult {
+    const errors: Record<string, string[]> = {};
+    let isValid = true;
+
+    for (const key in this.schema) {
+      const fieldRules = this.schema[key];
+      const value = data[key];
+      const fieldErrors: string[] = [];
+
+      for (const rule of fieldRules) {
+        const result = rule(value);
+        if (result !== true) {
+          fieldErrors.push(
+            typeof result === "string" ? result : "Invalid value",
+          );
+          isValid = false;
+        }
+      }
+
+      if (fieldErrors.length > 0) {
+        errors[key] = fieldErrors;
+      }
+    }
+
+    return { isValid, errors };
+  }
+
+  /**
+   * Validate a single field
+   */
+  public validateField(key: keyof T, value: any): string[] {
+    const rules = this.schema[key] || [];
+    const errors: string[] = [];
+
+    for (const rule of rules) {
+      const result = rule(value);
+      if (result !== true) {
+        errors.push(typeof result === "string" ? result : "Invalid value");
+      }
+    }
+
+    return errors;
+  }
+}

package/src/services/Validation-Service/rules.ts

@@ -0,0 +1,338 @@
+// All rules return true or a string (error message) to plug directly into v-text-field `rules` prop
+
+export type RuleFn<T = any> = (value: T) => true | string;
+
+const isEmpty = (v: unknown) =>
+  v === null ||
+  v === undefined ||
+  (typeof v === "string" && v.trim() === "") ||
+  (Array.isArray(v) && v.length === 0);
+
+export const required =
+  (msg = "This field is required"): RuleFn =>
+  (value) => {
+    return !isEmpty(value) || msg;
+  };
+
+export const email =
+  (msg = "Please enter a valid email"): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true; // allow empty unless required is also used
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value).trim()) || msg;
+  };
+
+// At least 6 chars, 1 uppercase, 1 lowercase, 1 number, 1 special character
+export const password =
+  (
+    msg = "Password must be at least 6 characters long and include uppercase, lowercase, numbers and a special character",
+  ): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const re = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^A-Za-z0-9\s])[^\s]{6,}$/;
+    return re.test(String(value).trim()) || msg;
+  };
+
+// check for leading or trailing spaces
+export const noLeadingTrailingSpaces =
+  (msg = "No leading or trailing spaces allowed"): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const str = String(value);
+    return str === str.trim() || msg;
+  };
+
+// international phone (10+ digits)
+export const phone =
+  (msg = "Please enter a valid phone number"): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    return /^\d{10,15}$/.test(String(value).trim()) || msg;
+  };
+
+// Builders for custom needs
+export const minLength =
+  (len: number, msg?: string): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    return (
+      String(value).length >= len || msg || `Must be at least ${len} characters`
+    );
+  };
+
+export const maxLength =
+  (len: number, msg?: string): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    return (
+      String(value).length <= len || msg || `Must be at most ${len} characters`
+    );
+  };
+
+export const pattern =
+  (re: RegExp, msg = "Invalid value"): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    return re.test(String(value)) || msg;
+  };
+
+export const equals =
+  (
+    other: () => string | number | boolean | null | undefined,
+    msg = "Values do not match",
+  ): RuleFn<any> =>
+  (value) => {
+    return value === other() || msg;
+  };
+
+export const notEquals =
+  (
+    other: () => string | number | boolean | null | undefined,
+    msg = "Values must not match",
+  ): RuleFn<any> =>
+  (value) => {
+    return value !== other() || msg;
+  };
+
+// File-specific validation rules
+export const fileSize =
+  (maxBytes: number, msg?: string): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    const maxMB = Math.round((maxBytes / (1024 * 1024)) * 10) / 10;
+    return (
+      file.size <= maxBytes || msg || `File size must be less than ${maxMB}MB`
+    );
+  };
+
+export const minFileSize =
+  (minBytes: number, msg?: string): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    const minMB = Math.round((minBytes / (1024 * 1024)) * 10) / 10;
+    return (
+      file.size >= minBytes || msg || `File size must be at least ${minMB}MB`
+    );
+  };
+
+export const fileType =
+  (allowedTypes: string[], msg?: string): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    return (
+      allowedTypes.includes(file.type) ||
+      msg ||
+      `File type ${file.type} is not allowed`
+    );
+  };
+
+export const fileExtension =
+  (allowedExtensions: string[], msg?: string): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    const fileExt = "." + file.name.split(".").pop()?.toLowerCase();
+    const allowedExtsLower = allowedExtensions.map((ext) => ext.toLowerCase());
+    return (
+      allowedExtsLower.includes(fileExt) ||
+      msg ||
+      `File extension ${fileExt} is not allowed`
+    );
+  };
+
+export const imageFile =
+  (msg = "Please select a valid image file"): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    return file.type.startsWith("image/") || msg;
+  };
+
+export const pdfFile =
+  (msg = "Please select a valid PDF file"): RuleFn<File> =>
+  (file) => {
+    if (!file) return true;
+    return file.type === "application/pdf" || msg;
+  };
+
+// Helper to combine multiple rules into one rule function (short-circuits on first error)
+export const composeRules =
+  (...rules: RuleFn[]): RuleFn =>
+  (value) => {
+    for (const rule of rules) {
+      const res = rule(value);
+      if (res !== true) return res;
+    }
+    return true;
+  };
+
+export const numericValue =
+  (msg = "Please enter a valid number"): RuleFn<string> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const numberRegex = /^\d*$/;
+    return numberRegex.test(String(value)) || msg;
+  };
+
+// Date range validation rules
+export const dateRange =
+  (
+    _msg = "Please select a valid date range",
+  ): RuleFn<{ from: string | null; to: string | null }> =>
+  (value) => {
+    if (!value || (isEmpty(value.from) && isEmpty(value.to))) return true;
+
+    // If only one date is selected, both should be selected
+    if ((value.from && !value.to) || (!value.from && value.to)) {
+      return "Please select both from and to dates";
+    }
+
+    // If both dates are selected, validate the range
+    if (value.from && value.to) {
+      const fromDate = new Date(value.from);
+      const toDate = new Date(value.to);
+
+      if (fromDate >= toDate) {
+        return "From date must be before to date";
+      }
+    }
+
+    return true;
+  };
+
+export const dateRangeRequired =
+  (
+    msg = "Date range is required",
+  ): RuleFn<{ from: string | null; to: string | null }> =>
+  (value) => {
+    if (!value || isEmpty(value.from) || isEmpty(value.to)) {
+      return msg;
+    }
+    return true;
+  };
+
+export const maxDateRange =
+  (
+    maxDays: number,
+    msg?: string,
+  ): RuleFn<{ from: string | null; to: string | null }> =>
+  (value) => {
+    if (!value || isEmpty(value.from) || isEmpty(value.to)) return true;
+
+    const fromDate = new Date(value.from as string);
+    const toDate = new Date(value.to as string);
+    const diffTime = toDate.getTime() - fromDate.getTime();
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+    return (
+      diffDays <= maxDays || msg || `Date range cannot exceed ${maxDays} days`
+    );
+  };
+
+export const positiveNumber =
+  (msg = "Please enter a positive number"): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (!isNaN(num) && num > 0) || msg;
+  };
+
+export const nonNegativeNumber =
+  (msg = "Please enter a non-negative number"): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (!isNaN(num) && num >= 0) || msg;
+  };
+
+export const integerValue =
+  (msg = "Please enter a whole number"): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (!isNaN(num) && Number.isInteger(num)) || msg;
+  };
+
+export const minValue =
+  (min: number, msg?: string): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (
+      (!isNaN(num) && num >= min) || msg || `Value must be at least ${min}`
+    );
+  };
+
+export const maxValue =
+  (max: number, msg?: string): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (!isNaN(num) && num <= max) || msg || `Value must be at most ${max}`;
+  };
+
+export const halfStepNumber =
+  (msg = "Please enter a number in 0.5 increments"): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return (!isNaN(num) && (num * 2) % 1 === 0) || msg;
+  };
+
+export const isNumber =
+  (msg = "Please enter a valid number"): RuleFn<string | number> =>
+  (value) => {
+    if (isEmpty(value)) return true;
+    const num =
+      typeof value === "number"
+        ? value
+        : parseFloat(String(value).replace(/,/g, ""));
+    return !isNaN(num) || msg;
+  };
+
+export const Rules = {
+  required,
+  email,
+  password,
+  noLeadingTrailingSpaces,
+  phone,
+  minLength,
+  maxLength,
+  pattern,
+  equals,
+  composeRules,
+  numericValue,
+  dateRange,
+  dateRangeRequired,
+  maxDateRange,
+  positiveNumber,
+  nonNegativeNumber,
+  integerValue,
+  minValue,
+  maxValue,
+  halfStepNumber,
+  isNumber,
+  fileSize,
+  minFileSize,
+  fileType,
+  fileExtension,
+  imageFile,
+  pdfFile,
+};
+
+export type { RuleFn as ValidationRuleFn };

package/src/services/Worker-Service/docs/WhatIsWorkerService.md

@@ -0,0 +1,57 @@
+# WorkerService
+
+The `WorkerService` allows you to offload heavy computations to a background thread without creating separate worker files. It creates workers dynamically using Blob URLs.
+
+## Overview
+
+Use this service when you have CPU-intensive tasks that would otherwise block the main thread and freeze the UI (e.g., sorting large arrays, image processing, complex filtering).
+
+### Key Features
+
+- **Dynamic Execution**: Pass a function and data, get a Promise back.
+- **No Setup**: No need to configure webpack/vite worker loaders for simple tasks.
+- **Type Safety**: Generic support for input and output types.
+
+## How to Use
+
+### 1. One-off Execution
+
+Execute a function in a worker and get the result.
+
+**⚠️ IMPORTANT LIMITATION**: The function passed to `execute` MUST be pure and self-contained. It **cannot** access variables from the outer scope (closures) because it is serialized to a string and run in a separate context.
+
+```typescript
+import { workerService } from "@/Worker-Service/workerService";
+
+// Example: Sorting a large array
+const largeArray = [
+  /* ... 100k items ... */
+];
+
+const sorted = await workerService.execute((data) => {
+  // This code runs in the worker
+  return data.sort((a, b) => a - b);
+}, largeArray);
+```
+
+### 2. Long-lived Worker
+
+If you need a worker that stays alive (e.g., for processing a stream of data), use `createWorker`.
+
+```typescript
+const worker = workerService.createWorker(() => {
+  self.onmessage = (e) => {
+    const result = e.data * 2;
+    self.postMessage(result);
+  };
+});
+
+worker.onmessage = (e) => console.log(e.data);
+worker.postMessage(10); // Logs: 20
+```
+
+## Best Practices
+
+1.  **Pure Functions**: Ensure your worker function relies _only_ on its arguments.
+2.  **Data Transfer**: Data passed to workers is cloned (structured clone algorithm). Avoid passing non-cloneable objects (like DOM elements or functions).
+3.  **Error Handling**: The `execute` method wraps errors, so use standard `try/catch`.

package/src/services/Worker-Service/workerService.ts

@@ -0,0 +1,122 @@
+export interface WorkerOptions {
+  timeout?: number;
+}
+
+export class WorkerService {
+  private static instance: WorkerService;
+
+  private constructor() {}
+
+  public static getInstance(): WorkerService {
+    if (!WorkerService.instance) {
+      WorkerService.instance = new WorkerService();
+    }
+    return WorkerService.instance;
+  }
+
+  /**
+   * Execute a function in a web worker.
+   * NOTE: The function `fn` must be strictly self-contained (no external closures).
+   *
+   * @param fn The function to execute.
+   * @param data The data to pass to the function.
+   * @param options Execution options (e.g., timeout).
+   */
+  public execute<T, R>(
+    fn: (data: T) => R,
+    data: T,
+    options?: WorkerOptions,
+  ): Promise<R> {
+    return new Promise((resolve, reject) => {
+      const code = `
+        self.onmessage = function(e) {
+          try {
+            const fn = ${fn.toString()};
+            const result = fn(e.data);
+            self.postMessage({ result, error: null });
+          } catch (error) {
+            self.postMessage({ result: null, error: error instanceof Error ? error.message : String(error) });
+          }
+        };
+      `;
+
+      const blob = new Blob([code], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      const worker = new Worker(url);
+      let timeoutId: any;
+
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        worker.terminate();
+        URL.revokeObjectURL(url);
+      };
+
+      worker.onmessage = (e) => {
+        const { result, error } = e.data;
+        cleanup();
+        if (error) {
+          reject(new Error(`Worker execution failed: ${error}`));
+        } else {
+          resolve(result);
+        }
+      };
+
+      worker.onerror = (e) => {
+        cleanup();
+        reject(new Error(`Worker error: ${e.message}`));
+      };
+
+      if (options?.timeout) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          reject(new Error(`Worker timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }
+
+      worker.postMessage(data);
+    });
+  }
+
+  /**
+   * Run a worker from a script file URL.
+   * @param scriptUrl URL of the worker script.
+   * @param data Data to pass.
+   * @param options Execution options.
+   */
+  public runWorker<T, R>(
+    scriptUrl: string,
+    data: T,
+    options?: WorkerOptions,
+  ): Promise<R> {
+    return new Promise((resolve, reject) => {
+      const worker = new Worker(scriptUrl);
+      let timeoutId: any;
+
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+        worker.terminate();
+      };
+
+      worker.onmessage = (e) => {
+        cleanup();
+        resolve(e.data as R);
+      };
+
+      worker.onerror = (e) => {
+        cleanup();
+        reject(new Error(`Worker error: ${e.message}`));
+      };
+
+      if (options?.timeout) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          reject(new Error(`Worker timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }
+
+      worker.postMessage(data);
+    });
+  }
+}
+
+export const workerService = WorkerService.getInstance();