@lmnto/h-mall-shared 1.0.1

package/shared/stores/cartStore.ts

@@ -0,0 +1,108 @@
+// user store
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+import { CATEGORY_FOR_SMART_PAY } from "../constants/app";
+import { ICart, UserAddress } from "../types/cart";
+
+interface ICommissionEligibilityFound {
+  status: boolean;
+  data?: Array<string>;
+}
+
+export type StoreType = {
+  cart: ICart | null;
+  cartQty: number;
+  haveSmartPay?: boolean;
+  loading: boolean;
+  userBillingAddress: UserAddress[];
+  userShippingAddress: UserAddress[];
+  commissionNonEligibleFound: ICommissionEligibilityFound;
+  paymentMethods: any;
+  setPaymentMethods: (methods: any) => void;
+  setUserBillingAddress: (address: UserAddress[]) => void;
+  setUserShippingAddress: (address: UserAddress[]) => void;
+  setCart: (cartData: ICart | null) => void;
+  setLoading: (newLoading: boolean) => void;
+  refechCart?: () => void | null;
+  setRefechCart: (fn: () => void) => void;
+};
+
+const checkSmartPayCategory = (cartProducts: any[]): boolean => {
+  return cartProducts?.some(
+    (item) => item.product?.category?.code === CATEGORY_FOR_SMART_PAY,
+  );
+};
+
+const getTotalProductQuantity = (cartProducts: any[]): number => {
+  if (!cartProducts || cartProducts?.length === 0) return 0;
+  let totalQuantity = 0;
+  cartProducts.forEach((item) => {
+    const itemQuantity = Number(item.quantity);
+    if (!isNaN(itemQuantity)) {
+      totalQuantity += itemQuantity;
+    }
+  });
+  return totalQuantity;
+};
+
+const checkNonEligibleProductForCommission = (
+  cartProducts: any[],
+): ICommissionEligibilityFound => {
+  let status = false;
+  let data = [];
+
+  if (cartProducts) {
+    cartProducts.forEach((item) => {
+      if (item.isEligibleForCommission === false) {
+        status = true;
+        data.push(`${item.product.category.name}`);
+      }
+    });
+  }
+
+  return {
+    status,
+    data,
+  };
+};
+
+export const useCartStore = create<StoreType>()(
+  persist(
+    (set, get) => ({
+      cart: get()?.cart ?? null, // Initial state for cart info
+      cartQty: get()?.cartQty ?? 0,
+      loading: true, // Tracks if cart data is loading
+      userBillingAddress: get()?.userBillingAddress ?? null,
+      userShippingAddress: get()?.userShippingAddress ?? null,
+      commissionNonEligibleFound: get()?.commissionNonEligibleFound ?? {
+        status: false,
+      },
+      refechCart: undefined,
+      paymentMethods: get()?.paymentMethods ?? null,
+      setCart: (data: ICart | null) =>
+        set({
+          cart: data,
+          haveSmartPay: data
+            ? checkSmartPayCategory(data?.cartProducts)
+            : false,
+          cartQty: data ? getTotalProductQuantity(data?.cartProducts) : 0,
+          commissionNonEligibleFound: checkNonEligibleProductForCommission(
+            data?.cartProducts,
+          ),
+          loading: false,
+        }), // Action to update
+      setLoading: (state: boolean) => set({ loading: state }), // Action to update loading state
+      setUserBillingAddress: (address: UserAddress[]) =>
+        set({ userBillingAddress: address }),
+      setUserShippingAddress: (address: UserAddress[]) =>
+        set({ userShippingAddress: address }),
+      setRefechCart: (fn: () => void) => set({ refechCart: fn }),
+      setPaymentMethods: (methods: any) => set({ paymentMethods: methods }),
+    }),
+    {
+      name: "cartStore",
+      storage: createJSONStorage(() => localStorage),
+    },
+  ),
+);

package/shared/stores/countriesStore.ts

@@ -0,0 +1,62 @@
+// user store
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+import { ICountries } from "../types/addressForm";
+
+export type StoreType = {
+  countries: ICountries[] | null;
+  shippingCountries: ICountries[] | null;
+  states: any[] | null;
+  shippingStates: any[] | null;
+  stores: any[] | null;
+  cities: any[] | null;
+  shippingCities: any[] | null;
+  loading: boolean;
+  loadingCities: boolean;
+  loadingShippingCities: boolean;
+  setCountries: (countries: ICountries[] | null) => void;
+  setShippingCountries: (countries: ICountries[] | null) => void;
+  setStates: (states: any[] | null) => void;
+  setShippingStates: (shippingStates: any[] | null) => void;
+  setStores: (stores: any[] | null) => void;
+  setCities: (cities: any[] | null) => void;
+  setShippingCities: (shippingCities: any[] | null) => void;
+  setLoading: (newLoading: boolean) => void;
+  setLoadingCities: (newLoading: boolean) => void;
+  setShippingLoadingCities: (loadingShippingCities: boolean) => void;
+};
+
+export const countriesStore = create<StoreType>()(
+  persist(
+    (set, get) => ({
+      countries: get()?.countries ?? null,
+      shippingCountries: get()?.shippingCountries ?? null,
+      states: [],
+      shippingStates: [],
+      cities: [],
+      shippingCities: [],
+      stores: [],
+      loading: true,
+      loadingCities: true,
+      loadingShippingCities: true,
+      setCountries: (newCountries: ICountries[]) =>
+        set({ countries: newCountries }),
+      setShippingCountries: (newCountries: ICountries[]) =>
+        set({ shippingCountries: newCountries }),
+      setStates: (newStates: any) => set({ states: newStates }),
+      setShippingStates: (newStates: any) => set({ shippingStates: newStates }),
+      setStores: (newStores: any) => set({ stores: newStores }),
+      setCities: (newCities: any) => set({ cities: newCities }),
+      setShippingCities: (newCities: any) => set({ shippingCities: newCities }),
+      setLoading: (newLoading: any) => set({ loading: newLoading }),
+      setLoadingCities: (newLoading: any) => set({ loadingCities: newLoading }),
+      setShippingLoadingCities: (newLoading: any) =>
+        set({ loadingShippingCities: newLoading }),
+    }),
+    {
+      name: "countriesStore",
+      storage: createJSONStorage(() => localStorage),
+    },
+  ),
+);

package/shared/stores/formStore.ts

@@ -0,0 +1,19 @@
+import { FieldValues, UseFormReturn } from "react-hook-form";
+import { create } from "zustand";
+
+export interface FormStoreType<T extends FieldValues> {
+  reactHookUseForm: { [key: string]: UseFormReturn<T> };
+  setReactHookUseForm: (data: { [key: string]: UseFormReturn<any> }) => void;
+}
+
+export const useFormStore = create<FormStoreType<any>>()((set) => ({
+  reactHookUseForm: {}, // Initial state
+  setReactHookUseForm: (data: { [key: string]: UseFormReturn<any> }) => {
+    set((state) => ({
+      reactHookUseForm: {
+        ...state.reactHookUseForm,
+        ...data,
+      },
+    }));
+  }, // Action to update
+}));

package/shared/stores/loadingStore.ts

@@ -0,0 +1,12 @@
+// app loading store
+import { create } from "zustand";
+
+export type StoreType = {
+  loading: boolean;
+  setLoading: (newLoading: boolean) => void;
+};
+
+export const useLoadingStore = create<StoreType>()((set) => ({
+  loading: false,
+  setLoading: (status: boolean) => set({ loading: status }),
+}));

package/shared/stores/userStore.ts

@@ -0,0 +1,32 @@
+// user store
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+
+import { IUserProfile } from "../types/user";
+
+export type StoreType = {
+  user: IUserProfile | null;
+  loading: boolean;
+  userConnected: boolean;
+  setUser: (userData: IUserProfile | null) => void;
+  setLoading: (newLoading: boolean) => void;
+  setUserConnected: (connectedStatus: boolean) => void;
+};
+
+export const useUserStore = create<StoreType>()(
+  persist(
+    (set, get) => ({
+      user: get()?.user ?? null, // Initial state for user info
+      loading: true, // Tracks if user data is loading
+      userConnected: get()?.userConnected ?? false, // initial user auth status
+      setUser: (newUser: any) => set({ user: newUser, userConnected: true }), // Action to update user info
+      setLoading: (newLoading: any) => set({ loading: newLoading }), // Action to update loading state
+      setUserConnected: (connectedStatus: boolean) =>
+        set({ userConnected: connectedStatus }), // Action to update the user auth status
+    }),
+    {
+      name: "userStore",
+      storage: createJSONStorage(() => sessionStorage),
+    },
+  ),
+);

package/shared/types/SelectComponent.types.ts

@@ -0,0 +1,31 @@
+import { JSX } from "react";
+
+export type SelectComponentProps = {
+  id?: string;
+  style?: React.CSSProperties;
+  className?: string;
+  classNameLabel?: string;
+  classNameOpened?: string;
+  classNameOption?: string;
+  classNamePlaceholder?: string;
+  classNameSearchInput?: string;
+  label?: string;
+  placeholder?: string;
+  value: any;
+  setValue: (value: any) => void;
+  items: any[];
+  labelKey?: string;
+  searchKey?: string;
+  icon?: JSX.Element;
+  iconTransitionSpeed?: number;
+  scrollToTopOnClose?: boolean;
+  disabled?: boolean;
+  maxHeightOpened?: number;
+  styleOpened?: React.CSSProperties;
+  styleClosed?: React.CSSProperties;
+  onSelectOpen?: () => void;
+  onSelectClose?: () => void;
+  onSelectChange?: (value: any) => void;
+  renderOption?: (item: any, fullItem: any) => React.ReactNode;
+  renderPlaceholder?: (item: any) => React.ReactNode;
+};

package/shared/types/addressForm.ts

@@ -0,0 +1,27 @@
+export type AddressForm = {
+  firstName: string;
+  lastName: string;
+  address: string;
+  buildingInfo: string;
+  countryId: number;
+  state: {
+    id: number;
+    name: string;
+  };
+  city: {
+    id: number;
+    name: string;
+  };
+};
+
+export interface ICountries {
+  id: number;
+  name: string;
+  code: string;
+  callingCode: string;
+  flag: string;
+  minPhoneLength: string;
+  zipCodeExists: boolean;
+  zipCodeRegex: string;
+  zipCodeExample: string;
+}

package/shared/types/cart.ts

@@ -0,0 +1,208 @@
+import { Commission } from "./payments";
+
+export interface ICart {
+  userBID: string;
+  reference: string;
+  cartProducts: any[]; // Replace 'any' with a specific type if known
+  billingAddressId: number | null;
+  shippingAddressId: number | null;
+  paymentMethodId: number | null;
+  id: number;
+  cartState: "shopping" | "checkout" | "completed"; // Define more states as needed
+  subTotal: string;
+  shippingTotal: string;
+  feeTotal: string;
+  taxTotal: string;
+  grandTotal: string;
+  utilityToken?: string;
+  smartPayPercentage?: string;
+  commissionSubTotal?: string;
+  isActive: boolean;
+  createdAt: string; // You could use Date if you plan to parse it
+  updatedAt: string;
+  fees: Fee[];
+  taxes: Tax[];
+  cartAsset: CartAsset;
+  isSmartPay: boolean;
+  isShippingApplicable?: boolean;
+  billingAddress: UserAddress;
+  paymentMethod: {
+    code: string;
+    id: number;
+    name: string;
+  };
+  shippingMethod: {
+    id: number;
+    name: string;
+    displayName: string;
+    code: string;
+    description: string;
+    isActive: boolean;
+    isDisplay: boolean;
+    isDeleted: boolean;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+  };
+}
+type CartAsset = {
+  id: number;
+  cartId: number;
+  assetOption: {
+    id: number;
+    name: string;
+    symbol: string;
+    isActive: boolean;
+    optionId: number;
+    provider: string;
+    createdAt: string;
+    deletedAt: string;
+    isDeleted: boolean;
+    updatedAt: string;
+    isVariable: boolean;
+    optionName: string;
+    displayOrder: number;
+    optionSymbol: string;
+    isAssetActive: boolean;
+    minPercentage: number;
+    optionIsActive: boolean;
+    paymentMethodId: number;
+    isCommissionEnabled: boolean;
+    commissionMultiplier: {
+      base: {
+        cv: number;
+        vp: number;
+      };
+      option: {
+        cv: number;
+        vp: number;
+      };
+    };
+  };
+  calculatedCommision: Commission;
+  baseAssetName: string;
+  baseAssetSymbol: string;
+  baseAssetAmount: number;
+  baseAssetPercentage: number;
+  optionAssetName: string;
+  optionAssetSymbol: string;
+  optionAssetAmount: number;
+  optionAssetPercentage: string;
+  createdAt: string;
+  updatedAt: string;
+};
+type Fee = {
+  amount: string;
+  cartId: number;
+  feeCategory: string;
+  feeName: string;
+  id: number;
+  type: string;
+  value: string;
+};
+type Tax = {
+  amount: string;
+  cartId: number;
+  id: number;
+  taxCategory: string;
+  taxName: string;
+  type: string;
+  value: string;
+};
+
+export type cartProduct = {
+  id: number;
+  sku: string;
+  name: string;
+  featureImage: string;
+  category: cartProductCategory;
+  price: number;
+  canProductBeRemoved: boolean;
+  canUserPurchaseTheProduct: boolean;
+  feedBackMessage: string;
+  maximumUserCanPurchase: number | null;
+  totalOrderExistsForProduct: number | null;
+  userPurchaseLimit: number | null;
+  maxCartQuantity: number | null;
+  quantityStepper: number | null;
+};
+
+export type cartProductCategory = {
+  id: number;
+  code: string;
+  name: string;
+};
+
+export type CartTableItemComponentProps = {
+  id: number;
+  product: cartProduct;
+  quantity: number;
+  cartProducts: number;
+  userPurchaseLimit: number | null;
+  maximumUserCanPurchase: number | null;
+  totalOrderExistsForProduct: number | null;
+  feedBackMessage: string;
+  canUserPurchaseTheProduct: boolean;
+  canProductBeRemoved: boolean;
+  unitOriginalPrice: number;
+  unitDiscount: number;
+  unitPrice: number;
+};
+
+export type BillingAddress = {
+  address: string;
+  buildingInfo: string;
+  city: string;
+  country: string;
+  countryId: number;
+  createdAt: string;
+  deletedAt: string;
+  id: number;
+  isActive: boolean;
+  isDefault: boolean;
+  isDeleted: boolean;
+  latitude: string;
+  longitude: string;
+  state: string;
+  type: string;
+  updatedAt: string;
+  userId: number;
+};
+export type UserAddress = {
+  id: number;
+  userBID: string;
+  firstName: string;
+  lastName: string;
+  phone: string;
+  email: string;
+  countryId: 3;
+  countryCode: string;
+  city: string;
+  state: string;
+  postalCode: string;
+  address: string;
+  buildingInfo: string;
+  latitude: string;
+  longitude: string;
+  type: string;
+  isDefault: boolean;
+  isActive: boolean;
+  isDeleted: boolean;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt: string;
+  country: {
+    id: 3;
+    name: string;
+    code: string;
+    alphaCode: string;
+    callingCode: string;
+    zipCodeExists: boolean;
+    zipCodeRegex: string;
+    isActive: boolean;
+    isDeleted: boolean;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+  };
+};

package/shared/types/category.ts

@@ -0,0 +1,6 @@
+export interface ICategory {
+  id: number;
+  name: string;
+  code?: any;
+  image?: string;
+}

package/shared/types/feature-flags.ts

@@ -0,0 +1,5 @@
+export interface IFeatureFlags {
+  name: string;
+  code: string;
+  isActive: boolean;
+}

package/shared/types/icon.ts

@@ -0,0 +1,5 @@
+export interface IconProps {
+  className?: string; // Optional className prop
+  width?: number;
+  height?: number;
+}

package/shared/types/index.d.ts

@@ -0,0 +1,84 @@
+import "react";
+
+declare module "react" {
+  interface HTMLAttributes<T> {
+    onPointerEnterCapture?: (e: React.PointerEvent<T | null>) => void;
+    onPointerLeaveCapture?: (e: React.PointerEvent<T | null>) => void;
+    placeholder?: string;
+    onResize?: any;
+    onResizeCapture?: any;
+  }
+  interface RefAttributes<T> {
+    onPointerEnterCapture?: (e: React.PointerEvent<T | null>) => void;
+    onPointerLeaveCapture?: (e: React.PointerEvent<T | null>) => void;
+    placeholder?: string;
+    onResize?: any;
+    onResizeCapture?: any;
+  }
+}
+
+type ObjectTypeDto = { [key: string]: string | number | unknown | Array<any> };
+
+interface DebounceFunction {
+  (...args: string[] | ObjectTypeDto[] | number[]): void;
+}
+
+export type RequestMethod = "POST" | "GET" | "DELETE" | "PUT" | "PATCH";
+
+export interface ApiResponseDto<T> {
+  status: boolean;
+  message: string;
+  msg?: string;
+  error?: any;
+  data?: T;
+  statusCode?: number;
+}
+
+export interface BooleanResultDto<T> {
+  status: boolean;
+  message: string;
+  data?: Array<T> | object | string | number | undefined | T | any;
+}
+
+export interface ResultPaginate<T> {
+  data: T;
+  page: number;
+  limit: number;
+  total: number;
+  sort: string;
+  totalPage: number;
+  nextPage: number;
+}
+
+export interface ITableComponentHeadersType {
+  name: string;
+  key: string;
+  canSort?: boolean;
+}
+
+export interface ITableComponentItemsType {
+  lineItems: {
+    key: string | "actions";
+    value: any;
+  }[];
+  isLast: boolean;
+}
+
+export interface IOrderTableComponentItemsType {
+  lineHeader: any;
+  lineItems: Array<
+    {
+      key: string | "actions";
+      value: any;
+    }[]
+  >;
+  isLast: boolean;
+}
+
+export interface ITableComponentItemActionsType {
+  name: string;
+  key: string;
+  isActive: boolean;
+  icon: any;
+  callback: () => void;
+}