@soma-vertical-web/multi-lib-sacurai 0.0.1

package/types/contexts/contexts/search.d.ts

@@ -0,0 +1,84 @@
+import { Dispatch, PropsWithChildren, SetStateAction } from 'react';
+import { ProductSearchResultPage } from '../../data/api/search/product';
+import { State, Suggestion } from '../../data/api/search';
+import { Facet, SelectedFacet } from '../../data/api/search/facets';
+import { ITEMS_DEFAULT_SORTType, ITEMS_PER_PAGEType, ITEMS_PER_SECTIONType, PLP_FILTERS_SORT_OPTIONtype, SEARCH_PAGE_ITEM_THRESHOLDType, SEARCH_RESULTType, VARIANT_PAGINATIONType } from '../../constants';
+import { BreadCrumbItemLinkProps } from '../../layout/team-components/PLPNavigation';
+import { ProductsProps } from '../../layout/templates/PLP';
+
+export interface FacetsContextProps {
+    breadcrumb: BreadCrumbItemLinkProps[];
+    deleteAllFacets(): void;
+    facets: Facet[];
+    isLoading: boolean;
+    selectedFacets: SelectedFacet[];
+    onToggleFacet(value: SelectedFacet): void;
+    onSort(sort: PLP_FILTERS_SORT_OPTIONtype): void;
+}
+export interface FacetsProviderProps extends PropsWithChildren {
+    forceUpdate?: boolean;
+}
+export interface FacetsProviderContentProps extends Omit<FacetsProviderProps, 'forceUpdate'> {
+    selectedFacets: SelectedFacet[];
+}
+export interface ProductsContextProps extends ProductSearchResultPage {
+    isLoading: boolean;
+    total: number;
+}
+export interface SuggestedTermsContextProps {
+    loading: boolean;
+    suggestedTerms: Suggestion['searches'];
+    setLoading: Dispatch<SetStateAction<boolean>>;
+}
+export interface SuggestedTermsProviderProps extends PropsWithChildren {
+    term?: string;
+}
+export interface ProductsProviderProps extends PropsWithChildren {
+    query?: string;
+    forceUpdate?: boolean;
+}
+export interface SearchContextProps extends Pick<SearchProviderProps, 'sort' | 'searchParams'> {
+    count: number;
+    state: State;
+}
+export interface SearchProviderProps extends PropsWithChildren {
+    searchParams: URLSearchParams;
+    state: State;
+    sort?: string;
+    collectionId?: number | null;
+    brand?: string | null;
+    count?: number;
+    ITEMS_PER_PAGE: ITEMS_PER_PAGEType;
+}
+export interface SearchItem {
+    term: string;
+    count: number;
+}
+export interface TopSearchesContextProps {
+    searches: SearchItem[];
+    isLoading: boolean;
+    error: string | null;
+}
+export type DataParams = FacetsContextProps | ProductSearchResultPage | SuggestedTermsContextProps;
+export interface RootContextProps {
+    data: DataParams | null;
+    isLoading: boolean;
+    isError?: boolean;
+}
+export interface RootProviderProps extends PropsWithChildren {
+    fetch: () => Promise<Response>;
+}
+export interface SearchStore extends Pick<RootContextProps, 'data'> {
+    isLoading?: boolean;
+    isError?: boolean;
+    fetchData: (fetcher: () => Promise<Response>) => Promise<void>;
+}
+export interface SearchConstantsProviderProps extends PropsWithChildren, Omit<ProductsProps, 'items' | 'isMobile'> {
+    ITEMS_PER_PAGE: ITEMS_PER_PAGEType;
+    ITEMS_DEFAULT_SORT: ITEMS_DEFAULT_SORTType;
+    ITEMS_PER_SECTION: ITEMS_PER_SECTIONType;
+    SEARCH_PAGE_ITEM_THRESHOLD: SEARCH_PAGE_ITEM_THRESHOLDType;
+    SEARCH_RESULT: SEARCH_RESULTType;
+    VARIANT_PAGINATION: VARIANT_PAGINATIONType;
+}
+export type SearchConstantsContextProps = Omit<SearchConstantsProviderProps, 'children'>;

package/types/contexts/contexts/session.d.ts

@@ -0,0 +1,87 @@
+import { PropsWithChildren } from 'react';
+import { AUTH_TOKEN_COOKIEType } from '../../constants';
+import { SessionEventProps } from '../../data/events';
+
+export interface SessionProviderProps extends PropsWithChildren, SessionEventProps {
+    AUTH_TOKEN_COOKIE: AUTH_TOKEN_COOKIEType;
+}
+interface BrandRef {
+    refid: string;
+    name: string;
+}
+interface ValueBox {
+    code: string;
+    document: string;
+    user_code: string;
+    cnpj: string;
+    value: number;
+    value_used: number;
+    trigger_amount: number;
+    type: any;
+    expiration_date: string | Date;
+    enabled: boolean;
+    created_at: string | Date;
+    gift_card_box: {
+        refid: string;
+        name: string;
+        description: string;
+        old_reference: any;
+        gift_card_property_enable: {
+            type_trigger_id: string;
+            trigger_amount: number;
+            trigger_amount_generation: number;
+            minimum_discount_value: number;
+            maximum_discount_value: number | null;
+            start_date_utilization: string | Date;
+            limit_percentage_discount: number | null;
+            requires_authentication: boolean;
+            start_days_utilization: number | null;
+        };
+    };
+    brand_creation: BrandRef;
+    brands_gift_card: BrandRef[];
+    remaining_value: number;
+}
+export type Boxes = {
+    gift_card_box: {
+        name: string;
+        refid: string;
+    };
+    amount: number;
+};
+export interface ISessionContext {
+    loading: boolean;
+    amount?: number | null;
+    boxes?: Boxes[] | null;
+    toExpire?: {
+        credito: ValueBox[] | null;
+        cashback: ValueBox[] | null;
+    } | null;
+    user?: {
+        id: string;
+        userId: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        homePhone: string;
+        phone: string;
+        gender: string;
+        document: string;
+        number: string;
+        city: string;
+        street: string;
+        postalCode: string;
+    };
+    wishlist?: string[];
+    token?: string;
+    texts?: {
+        welcome?: string;
+        description?: string;
+    };
+    logout: () => void;
+    getCurrentCredits: () => {
+        credits: number;
+        cashback: number;
+    };
+}
+export {};

package/types/contexts/hooks/index.d.ts

@@ -0,0 +1,19 @@
+import { PLP_GRID_SCROLL_BACKType } from '../../constants';
+import { Page } from '../contexts/plp';
+
+export interface UseBackPDCProps {
+    gridScrollBack?: {
+        refer: string;
+        key: string;
+    };
+}
+export type FetchPriority = 'auto' | 'high' | 'low';
+export type UseScrollRestorationProps = {
+    productCount: number;
+    PLP_GRID_SCROLL_BACK: PLP_GRID_SCROLL_BACKType;
+};
+export type UseScrollRestorationInfiniteProps = {
+    pages: Page[];
+    load: boolean;
+    PLP_GRID_SCROLL_BACK: PLP_GRID_SCROLL_BACKType;
+};

package/types/contexts/store/cart.d.ts

@@ -0,0 +1,212 @@
+import { PropsWithChildren } from 'react';
+import { OrderForm, PaymentData, OfferingItem, OrderFormMarketingData } from '../../data/api/checkout/order-form';
+import { ShippingOption, ShippingData } from '../../data/api/checkout/order-form/shipping';
+import { SearchProduct, SearchSort } from '../../data/api/search';
+import { ItemType_APICatalog } from '../../global/product';
+import { MAIN_IMAGEType } from '../../constants';
+import { ICartContent } from '../../cms/ContentTypes/Cart';
+
+/**
+ * TODO: Fix notification type
+ */
+export type CartItem = SearchProduct['node'];
+export type Order = {
+    label: string;
+    value: SearchSort | '';
+};
+export type FullCartItemDataRef = {
+    [key: string]: ItemType_APICatalog;
+};
+export interface CouponSellerProps {
+    type: 'coupon' | 'seller';
+}
+export interface AddToCart {
+    quantity?: number;
+    seller: string;
+    id: string;
+    index?: number;
+}
+export interface CartPromotionRules {
+    promotionId: string;
+    valueType: string;
+    totalValueToActivate: number;
+    remainingValueToActivate: number;
+    completeness: number;
+    isCompleted: boolean;
+}
+export interface CartProviderProps extends PropsWithChildren {
+    SELLER_CODE_VALIDATION_KEYS: Record<string, string>;
+    CARTPROVIDER_MESSAGE_PRODUCT_REMOVE?: string;
+    data?: ICartContent;
+}
+export type CodeResponseStatus = {
+    code?: number | string;
+    value?: string;
+    statusOk?: boolean;
+};
+export type CartItemOptionalProps = Record<string, string | undefined>;
+/**
+ * TODO: Fix notifications type
+ */
+export interface CartContextProps extends Omit<CartProviderProps, 'SELLER_CODE_VALIDATION_KEYS'> {
+    addToCart(item: AddToCart, options?: CartItemOptionalProps, force?: boolean): void;
+    addItemsToCart(items: AddToCart[], options?: CartItemOptionalProps[]): void;
+    addCouponSeller(value: string, type?: 'coupon' | 'seller'): Promise<CodeResponseStatus>;
+    /**
+     * TODO: Fix notifications type
+     */
+    notifications: any[];
+    cartStore: CartStore;
+    clearCart(): void;
+    isOpen: boolean;
+    setIsOpen(value: boolean): void;
+    removeToCart(productId: string, message?: string, callback?: () => void): Promise<CodeResponseStatus>;
+    shipping(postalCode?: string): Promise<OptionalOrderForm['shippingData'] | boolean>;
+    shippingUpdateOption(options?: ShippingOption[], postalCode?: string, country?: string): void;
+    toggleGiftItemCart(uniqueId: string, idOffering: string, remove: boolean): Promise<boolean | CartItemStore[] | undefined>;
+    updateItemQuantity(productId: string, quantity: number): Promise<string | boolean>;
+    removeCoupon(): Promise<void>;
+    removeSellerCode(): Promise<void>;
+    removeCEP(): Promise<void>;
+    promotionRules: CartPromotionRules | null;
+    setPromotionRules(rules: CartPromotionRules | null): void;
+}
+export interface OptionalOrderForm {
+    clientProfileData?: OrderForm['clientProfileData'];
+    marketingData?: OrderForm['marketingData'];
+    items?: CartItemStore[];
+    messages?: OrderForm['messages'];
+    openTextField?: OrderForm['openTextField'];
+    options?: CartItemOptionalProps[];
+    paymentData: PaymentData | null;
+    shippingData?: OrderForm['shippingData'];
+    totalizers?: OrderForm['totalizers'];
+}
+export type ShippingItem = Pick<CartItemStore, 'id' | 'quantity'> & {
+    seller: string;
+};
+export type AttachmentPropertyValue = {
+    name: string;
+    propertyID: string;
+    value: string;
+    valueReference: string;
+};
+export type CartItemForm = {
+    id: string;
+    quantity: number;
+    seller?: string;
+};
+export type OfferCartItem = {
+    availability: string;
+    listPrice: number;
+    price: number;
+    priceValidUntil: string;
+    priceCurrency: string;
+    itemCondition: string;
+    seller: string;
+};
+export type CartItemUpdate = {
+    id: string;
+    index?: number;
+    quantity: number;
+    seller: string;
+};
+export type CartItemOfferedImage = {
+    url: string;
+    alternateName: string;
+};
+export type CartItemSpecification = {
+    propertyID: string;
+    value: string;
+    name: string;
+    valueReference: string;
+};
+export type CartItemStore = {
+    availability: string;
+    bundleItems: Record<string, never>[];
+    id: string;
+    uniqueId: string;
+    referenceId: Array<{
+        Key: string;
+        Value: string;
+    }>;
+    productRefId: string;
+    ean: string;
+    itemOffered: {
+        additionalProperty: CartItemSpecification[];
+        brand: Record<string, string>;
+        categories: string[];
+        categoriesIds: string;
+        gtin: string;
+        name: string;
+        image: CartItemOfferedImage[];
+        isVariationOf: {
+            name: string;
+            productGroupID: string;
+        };
+        sku: string;
+        skuName?: string;
+        slug: string;
+    };
+    listPrice: number;
+    quantity: number;
+    price: number;
+    sellingPrice: number;
+    priceDefinition: {
+        calculatedSellingPrice: number;
+        total: number;
+        sellingPrices: Array<{
+            value: number;
+            quantity: number;
+        }>;
+    };
+    seller: string;
+    offerings: OfferingItem[];
+};
+export interface CartStore {
+    id: string;
+    isOpen: boolean;
+    items: CartItemStore[];
+    loading: boolean;
+    marketingData: OrderFormMarketingData | null;
+    messages: OrderForm['messages'];
+    openTextField: OrderForm['openTextField'];
+    options?: CartItemOptionalProps[];
+    paymentData: PaymentData | null;
+    shippingData: ShippingData | null;
+    itemMetadata: Array<Record<string, never>>;
+    totalizers: OrderForm['totalizers'];
+    recentlyAddedProducts: AddToCart[];
+    addCoupon(coupon: string): Promise<OptionalOrderForm['marketingData'] | boolean>;
+    addItem(item: AddToCart | AddToCart[], options?: CartItemOptionalProps[]): void;
+    addSellerCode(sellerCode: string, keys?: Record<string, string>): Promise<OptionalOrderForm['openTextField'] | boolean>;
+    addMarketingData(data: OrderFormMarketingData): Promise<OptionalOrderForm['marketingData'] | boolean>;
+    emptyCart(): void;
+    removeItem(id: string, callback?: (item?: CartItemStore) => void): Promise<boolean | string>;
+    setIsOpen(value: boolean): void;
+    shipping(postalCode?: string, country?: string): Promise<OptionalOrderForm['shippingData'] | boolean>;
+    shippingUpdate(options?: ShippingOption[], postalCode?: string, country?: string): Promise<OptionalOrderForm['shippingData'] | boolean>;
+    toggleServiceToProduct(uniqueId: string, itemIndex: number, remove: boolean): Promise<OptionalOrderForm['items'] | boolean>;
+    updateItemQuantity(id: string, quantity: number, options?: CartItemOptionalProps): Promise<OptionalOrderForm['items'] | boolean>;
+    insertProfileEmail(email: string): Promise<OptionalOrderForm['clientProfileData'] | boolean>;
+    setRecentlyAddedProducts(item: AddToCart | AddToCart[]): void;
+}
+export type Variant = 'default' | 'default-large' | 'unavailable' | 'order-details-page' | 'checkout-page';
+export interface UseRecentlyAddedProducts {
+    items: AddToCart[];
+}
+export type NotificationStore = {
+    id: number;
+    message: string;
+    callback?: () => void;
+};
+export interface NotificationsStore {
+    notifications: NotificationStore[];
+    actions: {
+        addNotification(message: string, callback?: () => void): void;
+        removeNotification(id: number): void;
+    };
+}
+export type OrderFormConstants = {
+    MAIN_IMAGE: MAIN_IMAGEType;
+};

package/types/contexts/store/header.d.ts

@@ -0,0 +1,18 @@
+export type HeaderCategoryStore = string | null;
+export type UseHeaderCategoryStoreType = {
+    value: HeaderCategoryStore;
+    actions: {
+        reset: () => void;
+        setValue: (value: HeaderCategoryStore) => void;
+        updateValue: (value: HeaderCategoryStore) => void;
+    };
+};
+export type MenuMobileIsOpenType = boolean;
+export type SearchModalIsOpenType = boolean;
+export type UserMenuIsOpenType = boolean;
+export interface HeaderInitialStateType {
+    category: HeaderCategoryStore;
+    menuMobileIsOpen: MenuMobileIsOpenType;
+    searchModalIsOpen: SearchModalIsOpenType;
+    userMenuIsOpen: UserMenuIsOpenType;
+}

package/types/contexts/store/helpers.d.ts

@@ -0,0 +1,7 @@
+export interface CommonUseStoreType<T = unknown> {
+    value: T;
+    actions: {
+        reset: () => void;
+        setValue: (value: T) => void;
+    };
+}

package/types/contexts/store/pdp.d.ts

@@ -0,0 +1,21 @@
+export type SelectedSkuInfoType = {
+    productId: string;
+    name: string;
+    size: string;
+    sku: string;
+    sellerId: string;
+    sellerName: string;
+    available: boolean;
+    quantity: number;
+};
+export type OpenLetMeKnowType = boolean;
+export type ShowNotifyType = boolean;
+export type ShowBottomNavigationType = boolean;
+export type OpenMeasurementsType = boolean;
+export interface PDPInitialStateType {
+    selectedSkuInfo: SelectedSkuInfoType;
+    openLetMeKnow: OpenLetMeKnowType;
+    openMeasurements: OpenMeasurementsType;
+    showBottomNavigation: ShowBottomNavigationType;
+    showNotify: ShowNotifyType;
+}

package/types/contexts/store/wishlist.d.ts

@@ -0,0 +1,17 @@
+export type WishListStateValue = {
+    feedback: {
+        active: boolean;
+        action: 'add' | 'remove' | '';
+    };
+    list: string[];
+};
+export type UseWishlistStoreType = {
+    value: WishListStateValue;
+    actions: {
+        reset: () => void;
+        setValue: (value: WishListStateValue) => void;
+        toggleProduct: (productId: string) => void;
+        updateList: (list: string[]) => void;
+        resetFeedback: () => void;
+    };
+};

package/types/data/api/catalog/portal/index.d.ts

@@ -0,0 +1,26 @@
+export type PortalPageType = CollectionPageType | FallbackPageType;
+export declare enum PageType {
+    Brand = "Brand",
+    Category = "Category",
+    Department = "Department",
+    SubCategory = "SubCategory",
+    Product = "Product",
+    Collection = "Collection",
+    Cluster = "Cluster"
+}
+export interface CollectionPageType {
+    id: number;
+    name: string;
+    url: string;
+    title: string;
+    metaTagDescription: string;
+    pageType: PageType;
+}
+export interface FallbackPageType {
+    id: null;
+    name: null | string;
+    url: null | string;
+    title: null;
+    metaTagDescription: null;
+    pageType: 'NotFound' | 'FullText';
+}

package/types/data/api/catalog/product/index.d.ts

@@ -0,0 +1,50 @@
+export type SimilarType = {
+    productId: string;
+    slug: string;
+    textureImage: string;
+    textureAlt: string;
+};
+export interface SimilarsResponseData {
+    items: Array<{
+        sellers: Array<{
+            commertialOffer: {
+                IsAvailable: boolean;
+            };
+        }>;
+        images: Array<{
+            imageLabel: string;
+            imageUrl: string;
+            imageText: string;
+        }>;
+    }>;
+    productId: string;
+    linkText: string;
+}
+export interface CategoryTree {
+    id: number;
+    name: string;
+    hasChildren: boolean;
+    url: string;
+    children: CategoryTree[];
+    Title: string;
+    MetaTagDescription: string;
+}
+type SEOType = Record<string, string>;
+export interface CreateSeoCategoryProps {
+    category: CategoryTree | null;
+    previousImages: any;
+    canonical: string;
+    seo: SEOType;
+}
+export interface CreateEmptySeoCategoryProps {
+    slug: string | string[];
+    canonical: string;
+    seo: SEOType;
+}
+export interface FindCategoryProps {
+    items: CategoryTree[];
+    parent: string;
+    apiUrl: string;
+    find?: string;
+}
+export {};

package/types/data/api/checkout/address/index.d.ts

@@ -0,0 +1,20 @@
+export interface AddressInput {
+    postalCode: string;
+    country: string;
+}
+export interface Address {
+    addressType: string;
+    receiverName: string | null;
+    addressId: string;
+    isDisposable: boolean;
+    postalCode: string;
+    city: string;
+    state: string;
+    country: string;
+    street: string;
+    number: string | null;
+    neighborhood: string;
+    complement: string | null;
+    reference: string | null;
+    geoCoordinates: [number, number];
+}