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

package/data/api/search/crosseling/index.d.ts

@@ -0,0 +1,91 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schema: yup.ArraySchema<{
+    value: string;
+    key: string;
+}[], yup.AnyObject, "", "">;
+type SchemaType = yup.InferType<typeof schema>;
+export declare function getSearchCrossellingProducts({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<{
+    node: {
+        sku: any;
+        gtin: any;
+        name: any;
+        description: any;
+        releaseDate: any;
+        slug: any;
+        video: any;
+        categories: any;
+        categoriesIds: any;
+        collection: any;
+        collectionId: any;
+        id: any;
+        brand: {
+            name: any;
+            brandName: any;
+        };
+        seo: {
+            description: any;
+            title: any;
+            canonical: string;
+        };
+        cluster: {
+            generals: any;
+            highlights: never[];
+        };
+        availability: {
+            status: boolean;
+        };
+        breadcrumbList: {
+            itemListElement: any[];
+            numberOfItems: any;
+        };
+        image: {
+            alternateName: string;
+            url: string;
+            keywords: string;
+        }[];
+        offers: {
+            lowPrice: number;
+            highPrice: number;
+            offers: {
+                availability: boolean;
+                listPrice: number;
+                price: number;
+                priceValidUntil: string;
+                priceCurrency: string;
+                installments: import('../../../../types/global/product').InstallmentType[];
+                lowPrice: number;
+                quantity: number;
+                seller: {
+                    identifier: string;
+                };
+            }[];
+        };
+        additionalProperty: ({
+            name: string;
+            value: Record<string, string>;
+            valueReference: "ATTACHMENT";
+        } | {
+            propertyID: string;
+            name: string;
+            value: string;
+            valueReference: {
+                valueReference: "ATTRIBUTE";
+                visible: boolean;
+            };
+        } | {
+            name: string;
+            value: string;
+            valueReference: "SPECIFICATION";
+        })[];
+        isVariantOf: {
+            productGroupID: any;
+            hasVariant: any;
+        };
+        installments: {
+            count: number;
+            value: number;
+        };
+    };
+}[] | undefined>;
+export {};

package/data/api/search/facets/index.d.ts

@@ -0,0 +1,4 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import { GetSearchFacetsResponse } from '../../../../types/data/api/search';
+
+export declare function getSearchFacets({ body, extraData, ...props }: FetchFunctionsProps<any>): GetSearchFacetsResponse;

package/data/api/search/index.d.ts

@@ -0,0 +1,6 @@
+export * from './autoCompleteSuggestions';
+export * from './crosseling';
+export * from './product';
+export * from './facets';
+export * from './suggestedTerms';
+export * from './topSearch';

package/data/api/search/product/index.d.ts

@@ -0,0 +1,3 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+
+export declare function getSearchProducts({ body, extraData, ...props }: FetchFunctionsProps<any>): Promise<any>;

package/data/api/search/searchFetch.d.ts

@@ -0,0 +1,3 @@
+import { SearchAPIProps } from '../../../types/data/api/search';
+
+export declare const search: ({ apiUrl, body, fetchOptions, extraData }: SearchAPIProps) => Promise<unknown> | undefined;

package/data/api/search/suggestedTerms/index.d.ts

@@ -0,0 +1,12 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schema: yup.ObjectSchema<{
+    query: string | undefined;
+    locale: string | undefined;
+}, yup.AnyObject, {
+    query: undefined;
+    locale: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schema>;
+export declare function getSearchSuggestedTerms({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};

package/data/api/search/topSearch/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getSearchTopSearchs({ apiUrl }: {
+    apiUrl: string;
+}): Promise<any>;

package/data/api/wishlist/products/index.d.ts

@@ -0,0 +1,3 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+
+export declare function getWishlistProducts({ body, apiUrl, extraData, fetchOptions }: FetchFunctionsProps<any>): Promise<any>;

package/data/helpers/cart/index.d.ts

@@ -0,0 +1,247 @@
+import { FetchPriority } from '../../../types/contexts/hooks';
+import { OrderFormItem, OrderForm, SelectedAddress } from '../../../types/data/api/checkout/order-form';
+import { AddToCart, CartItem, CartItemOptionalProps, CartItemStore, OrderFormConstants, NotificationsStore, OptionalOrderForm } from '../../../types/contexts/store/cart';
+
+export declare const VALUE_REFERENCES: {
+    readonly attachment: "ATTACHMENT";
+    readonly specification: "SPECIFICATION";
+    readonly attribute: "ATTRIBUTE";
+};
+export declare const promiseDefault: Promise<boolean>;
+export declare const initialState: {
+    id: string;
+    isOpen: boolean;
+    items: never[];
+    loading: boolean;
+    marketingData: null;
+    messages: never[];
+    openTextField: {};
+    paymentData: null;
+    shippingData: null;
+    totalizers: never[];
+    itemMetadata: never[];
+    recentlyAddedProducts: never[];
+    addCoupon: () => Promise<boolean>;
+    addItem: () => Promise<boolean>;
+    addSellerCode: () => Promise<boolean>;
+    addMarketingData: () => Promise<boolean>;
+    emptyCart: () => {};
+    removeItem: () => Promise<boolean>;
+    setIsOpen: () => {};
+    shipping: () => Promise<boolean>;
+    shippingUpdate: () => Promise<boolean>;
+    toggleServiceToProduct: () => Promise<boolean>;
+    updateItemQuantity: () => Promise<boolean>;
+    insertProfileEmail: () => Promise<boolean>;
+    setRecentlyAddedProducts: () => {};
+};
+export declare const isGift: (price: number) => price is 0;
+export declare const getCategories: (productCategoryIds: string, productCategories: {
+    [key: string]: string;
+}) => string[];
+export declare const createItemOrder: (item: OrderFormItem, CONSTANTS?: OrderFormConstants) => CartItemStore;
+export declare const addItemOrder: (items: CartItemStore[], item: AddToCart | AddToCart[]) => AddToCart[];
+export declare const removeQuantity: (items: CartItemStore[], id: string) => {
+    updateItems: {
+        id: string;
+        index: number;
+        quantity: number;
+        seller: string;
+    }[];
+    filterItems: {
+        id: string;
+        index: number;
+        quantity: number;
+        seller: string;
+    }[];
+};
+export declare const updateQuantity: (items: CartItemStore[], id: string, quantity: number) => {
+    id: string;
+    index: number;
+    quantity: number;
+    seller: string;
+    sku: string;
+}[];
+export declare const findItemIndex: (items: CartItemStore[], id: string) => number;
+export declare const findTotalizerValue: (totalizers: Array<{
+    id: string;
+    name: string;
+    value: number;
+}>, id: string) => number;
+export declare const getTotalizer: (items: CartItemStore[]) => {
+    totalItems: number;
+    total: number;
+    subTotal: number;
+};
+export declare const getTotalItems: (items?: CartItemStore[]) => number;
+export declare const orderFormValues: (orderForm: OrderForm, CONSTANTS?: OrderFormConstants) => {
+    id: string;
+    items: CartItemStore[];
+    salesChannel: string;
+    loggedIn: boolean;
+    isCheckedIn: boolean;
+    storeId: string | null;
+    checkedInPickupPointId: string | null;
+    allowManualPrice: boolean;
+    canEditData: boolean;
+    userProfileId: string | null;
+    userType: string | null;
+    ignoreProfileData: boolean;
+    value: number;
+    messages: any[];
+    selectableGifts: any[];
+    totalizers: Array<{
+        id: string;
+        name: string;
+        value: number;
+    }>;
+    shippingData: import('../../../types/data/api/checkout/order-form/shipping').ShippingData | null;
+    clientProfileData: import('../../../types/data/api/checkout/order-form/profile').ClientProfileData | null;
+    paymentData: import('../../../types/data/api/checkout/order-form').PaymentData;
+    marketingData: import('../../../types/data/api/checkout/order-form').OrderFormMarketingData | null;
+    sellers: Array<{
+        id: string;
+        name: string;
+        logo: string;
+    }>;
+    clientPreferencesData: {
+        locale: string;
+        optinNewsLetter: unknown;
+    };
+    commercialConditionData: unknown;
+    storePreferencesData: {
+        countryCode: string;
+        currencyCode: string;
+        currencyFormatInfo: {
+            currencyDecimalDigits: number;
+            currencyDecimalSeparator: string;
+            currencyGroupSeparator: string;
+            currencyGroupSize: number;
+            startsWithCurrencySymbol: boolean;
+        };
+        currencyLocale: number;
+        currencySymbol: string;
+        saveUserData: boolean;
+        timeZone: string;
+    };
+    giftRegistryData: unknown;
+    openTextField: Record<string, string | boolean>;
+    invoiceData: unknown;
+    customData: import('../../../types/data/api/checkout/order-form').OrderFormCustomData | null;
+    itemMetadata: {
+        items: import('../../../types/data/api/checkout/order-form').MetadataItem[];
+    } | null;
+    hooksData: unknown;
+    ratesAndBenefitsData: {
+        rateAndBenefitsIdentifiers: any[];
+        teaser: any[];
+    };
+    subscriptionData: import('../../../types/data/api/checkout/order-form').SubscriptionData | null;
+    itemsOrdination: unknown;
+};
+export declare const updateItemSellerExternal: (items: CartItemStore[], productId: string) => boolean;
+export declare const getSize: (item: CartItem, NAME_SPLIT_SYMBOL: string) => string;
+export declare const getCode: (data: string, value: string, statusOk?: boolean) => {
+    code: number;
+    value: string;
+    statusOk: boolean;
+};
+export declare const wishlistArray: (productNode: CartItem, wishlist: CartItem[]) => {
+    slug: string;
+    sku: string;
+    name: string;
+    gtin: string;
+    id: string;
+    brand: {
+        name: string;
+        brandName: string;
+    };
+    isVariantOf: {
+        hasVariant: Array<{
+            sku: string;
+            name: string;
+            gtin: string;
+            id: string;
+            brand: {
+                name: string;
+                brandName: string;
+            };
+            isVariantOf: {
+                productGroupID: string;
+                name: string;
+            };
+            image: Array<{
+                url: string;
+                alternateName: string;
+            }>;
+            offers: {
+                lowPrice: number;
+                offers: Array<{
+                    availability: string;
+                    price: number;
+                    listPrice: number;
+                    quantity: number;
+                    seller: {
+                        identifier: string;
+                    };
+                }>;
+            };
+        }>;
+        productGroupID: string;
+        name: string;
+        additionalProperty: Array<{
+            propertyID: string;
+            name: string;
+            value: any;
+            valueReference: string;
+        }>;
+    };
+    categories: Array<string>;
+    referenceId: Array<{
+        Key: string;
+        Value: string;
+    }>;
+    image: Array<{
+        url: string;
+        alternateName: string;
+    }>;
+    offers: {
+        lowPrice: number;
+        offers: Array<{
+            availability: string;
+            price: number;
+            listPrice: number;
+            quantity: number;
+            seller: {
+                identifier: string;
+            };
+            priceValidUntil: string;
+            priceCurrency: string;
+            itemCondition: string;
+        }>;
+    };
+}[];
+export declare const getRemoveId: (productId: string, items?: CartItemStore[] | boolean) => Promise<boolean> | Promise<string>;
+export declare const getValue: <K extends keyof OptionalOrderForm>(order: OptionalOrderForm, key?: K) => Promise<boolean> | Promise<Awaited<OptionalOrderForm[K]>>;
+export declare const updateOrderFormPromise: (callback: () => Promise<OptionalOrderForm | boolean>) => Promise<false | OptionalOrderForm>;
+export declare const getQuantity: (quantity: number, index: number) => number;
+export declare const findOptions: (options?: CartItemOptionalProps[], items?: OptionalOrderForm["items"]) => CartItemOptionalProps[];
+export declare const mergeOptionsPromise: (res: Promise<Array<CartItemOptionalProps> | undefined>, options?: CartItemOptionalProps[]) => Promise<CartItemOptionalProps[]>;
+export declare const fetchCartAPI: (url: string, params: {
+    priority?: FetchPriority;
+    body: Record<string, unknown>;
+}, skipSanitize?: boolean, CONSTANTS?: OrderFormConstants) => Promise<any>;
+export declare const addNotification: (state: NotificationsStore, message: string, callback?: () => void) => {
+    notifications: import('../../../types/contexts/store/cart').NotificationStore[];
+};
+export declare const marketingTagsBuilder: (marketingTags: string | string[]) => string[];
+export declare const mountMarketingData: (searchParams: URLSearchParams) => {
+    utmipage?: string | undefined;
+    utmiPart?: string | undefined;
+    utmiCampaign?: string | undefined;
+    utmCampaign?: string | undefined;
+    utmMedium?: string | undefined;
+    utmSource?: string | undefined;
+};
+export declare const getUrlParameter: (name: string) => string | null | undefined;
+export declare const createNewAddress: (postalCode: string, geo: object | null, country?: string) => SelectedAddress[];

package/data/helpers/catalog/index.d.ts

@@ -0,0 +1,38 @@
+import { CreateEmptySeoCategoryProps, CreateSeoCategoryProps, FindCategoryProps, SimilarsResponseData, SimilarType } from '../../../types/data/api/catalog/product';
+import { CollectionPageType } from '../../../types/data/api/catalog/portal';
+import { ProductType_APICatalog } from '../../../types/global/product';
+import { TEXTURE_IMAGEType } from '../../../types/constants';
+
+export declare const createEmptySeoCategory: ({ canonical, seo, slug }: CreateEmptySeoCategoryProps) => {
+    id: number;
+    Title: string;
+    MetaTagDescription: string;
+    name: string;
+    hasChildren: boolean;
+    url: string;
+    children: never[];
+};
+export declare const createSeoCategory: ({ canonical, category, previousImages, seo }: CreateSeoCategoryProps) => {
+    category: string;
+    title: string;
+    description: string;
+    alternates: {
+        canonical: string;
+    };
+    openGraph: {
+        type: string;
+        title: string;
+        description: string;
+        images: any[];
+    };
+};
+export declare const findCategory: ({ items, parent, apiUrl, find }: FindCategoryProps) => import('../../../types/data/api/catalog/product').CategoryTree | undefined;
+export declare const notFindCategoryError: (error: Error) => void;
+export declare const isCollectionPageType: (x: any) => x is CollectionPageType;
+export declare const responseAdapter: (data: ProductType_APICatalog) => {
+    collection: string[];
+    categoryId: string;
+    current_collection: string[];
+    items: import('../../../types/global/product').ItemType_APICatalog[];
+};
+export declare const formattedSimilars: (data: SimilarsResponseData[], filterTexture: TEXTURE_IMAGEType) => SimilarType[];

package/data/helpers/cms/index.d.ts

@@ -0,0 +1,10 @@
+export declare function strapiCMSData<T>(url: URL, params?: Record<string, unknown>, spreadData?: boolean): Promise<{
+    status: number | string;
+    data: T[];
+    error?: string;
+}>;
+export declare function vtexCMSData<T>(contentType: string, url: URL, params?: Record<string, unknown>): Promise<{
+    status: number | string;
+    data: T[] | T | null;
+    error?: string;
+}>;

package/data/helpers/events/index.d.ts

@@ -0,0 +1,29 @@
+import { EventsFunctionType, ProductsPersisteDataType, PersistedDataType } from '../../../types/data/events';
+import { SizeInfoType } from '../../../types/global/product';
+
+export declare const pushDatalayer: ({ event, data, }: {
+    event?: string;
+    data?: any;
+}) => void;
+export declare const eventsFunctions: EventsFunctionType;
+export declare const getAvailablesSizes: (sizes: SizeInfoType[]) => string;
+export declare const getCategories: (breadcrumbList: string[]) => {
+    item_category3?: string | undefined;
+    item_category2?: string | undefined;
+    item_category?: string | undefined;
+};
+export declare const getProductListInfoFromHead: () => string[];
+export declare const getPersistedData: () => any;
+export declare const findDataInPersistedData: (persistedData: ProductsPersisteDataType, sku: string) => PersistedDataType;
+export declare const updatePersistedData: ({ persistedData, type, sku, newData, }: {
+    persistedData: ProductsPersisteDataType;
+    type: "add" | "remove";
+    sku: string;
+    newData?: PersistedDataType;
+}) => void;
+export declare const getPageCategoryAndDepartmentFromSlug: () => {
+    page_category: string;
+    page_departament: string;
+    id: string;
+    name: string;
+};

package/data/helpers/plp/index.d.ts

@@ -0,0 +1,85 @@
+import { State } from '../../../types/data/api/search/index';
+import { ProductSearchResultPage } from '../../../types/data/api/search/product';
+import { ProductNode_PDC } from '../../../types/global/product';
+import { PLPBanners, Page, PLPInfiniteContextProps } from '../../../types/contexts/contexts/plp';
+
+export declare const deepEqual: (a: any, b: any) => boolean;
+export declare const hasStateChangedExceptPage: (prev: State, next: State, excludeKey?: keyof State) => boolean;
+export declare const fetchPage: (payload: State) => Promise<ProductSearchResultPage>;
+export declare const createProduct: () => ProductNode_PDC;
+export declare const getBanners: (banners: PLPBanners, page: number, columns: number, itemsPerPage?: number) => {
+    placedBanners: number[];
+    taken: Set<number>;
+};
+export declare const getPositions: (banners: PLPBanners, page: number, columns: number, itemsPerPage?: number) => {
+    banners: number[];
+    products: number[];
+};
+export declare const createPages: (page: number, data?: ProductSearchResultPage, itemsPerPage?: number) => {
+    loading: boolean;
+    page: number;
+    pagination: {
+        nextPage: boolean;
+        previousPage: boolean;
+        startCursor: string;
+        endCursor: string;
+        count: number;
+        total: number;
+    };
+    products: ProductNode_PDC[];
+}[];
+export declare const createPage: (pages: Page[], newPage: number) => Page[];
+export declare const createPagination: () => {
+    nextPage: boolean;
+    previousPage: boolean;
+    startCursor: string;
+    endCursor: string;
+    count: number;
+    total: number;
+};
+export declare const getVisibleBanners: (pages: Page[], banners: PLPBanners, products: PLPInfiniteContextProps["products"], bannersPositions: PLPInfiniteContextProps["banners"], count: number) => ({
+    columns: number;
+    position_grid: number;
+} & {
+    borderTop: boolean;
+    textStructure: string;
+    textStructureReduced: string;
+    enableIcon: boolean;
+    textStructureButtonIcon: string;
+    textStructureButtonLabel: string;
+    textStructureButtonSize: import('@soma-vertical-web/foundations').TSizesSmallExtended;
+    textStructureButtonHref: string;
+    textStructureMode: import('@soma-vertical-web/foundations').TMode;
+    textStructureAlignment: import('../../../types/cms/Sections/TextContent').ContentAlignment;
+    showTextStructureExpander: boolean;
+} & {
+    promotion_id: string;
+    promotion_name: string;
+    creative_name: string;
+    creative_slot: string;
+    isHeroBanner: boolean;
+    backgroundColor: string;
+    contentOrder: string;
+    video: string;
+    position: import('../../../types/cms/Sections/Banner').Position;
+    image: string;
+    imageHref: string;
+    imageOpacity: boolean;
+    altImage: string;
+    showTimer: boolean;
+    timerEnd: string;
+    timerInit: string;
+    timerMode: import('@soma-vertical-web/foundations').TMode;
+    timerSize: string;
+    contentAlignment: import('../../../types/cms/Sections/Banner').ContentAlignment;
+    title: string;
+    href?: string;
+    index?: number;
+    headerVariant: import('@soma-vertical-web/core-components/src/lib/Header/interfaces').VariantsType;
+})[];
+export declare const getRandomVideoPerRow: (positions: number[], columns: number) => number[];
+export declare const getProductsWithVideo: (products: ProductNode_PDC["node"][], columns: number) => number[];
+export declare const createBreadcrumb: (root: string[]) => {
+    href: string;
+    name: string;
+}[];

package/data/helpers/product/generalInfo.d.ts

@@ -0,0 +1,19 @@
+import { HasVariant } from '../../../types/global/product';
+
+export declare const splitNameAndSizeFromFullName: (fullName: string, NAME_SPLIT_SYMBOL: string) => {
+    name: string;
+    size: string;
+};
+export declare const getColorAndSizeFromSkuName: (skuName: string, NAME_SPLIT_SYMBOL: string) => {
+    color?: undefined;
+    size?: undefined;
+} | {
+    color: string;
+    size: string;
+};
+export declare const getSKUName: (item: HasVariant, key?: string) => string;
+export declare const getProductNameWithoutSku: (fullName: string, skuName: string) => string;
+/**
+ * TODO: check if this function is still needed
+ */
+export declare const removeSlashes: (text: string) => string;

package/data/helpers/product/image.d.ts

@@ -0,0 +1,17 @@
+import { ProductCardProps } from '../../../types/layout/team-components/ProductCard';
+import { GetFirstImagesProps } from '../../../types/data/helpers';
+
+export declare const resizingImg: (url: string, imageResize: {
+    width: number;
+    height: number;
+}) => string;
+export declare const updatedResizedImg: (url: string, imageResize: {
+    width: number;
+    height: number;
+}) => string;
+export declare const getFirstImages: ({ images, label }: GetFirstImagesProps) => ProductCardProps["image"];
+/**
+ * TODO: check if this function is still needed
+ */
+export declare const getAspectRatio: (aspectRatio: string) => number;
+export declare const setVideoPlay: (isIntersection: boolean, element: HTMLVideoElement | null, url?: string) => void;

package/data/helpers/product/index.d.ts

@@ -0,0 +1,7 @@
+export * from './price';
+export * from './skuInfos';
+export * from './thumb';
+export * from './generalInfo';
+export * from './image';
+export * from './price';
+export * from './skuInfos';

package/data/helpers/product/orderSizes.d.ts

@@ -0,0 +1,3 @@
+import { OrderSizesProps } from '../../../types/data/helpers';
+
+export declare const orderSizes: <T>({ items, getLabel, PLP_SIZE_ORDER }: OrderSizesProps) => T[];

package/data/helpers/product/price.d.ts

@@ -0,0 +1,5 @@
+import { ParsePriceProps } from '../../../types/data/helpers/index';
+
+export declare const formatPriceToCurrency: (value: number, hasDecimal?: boolean) => string;
+export declare const freightParsePrice: ({ valueInCents, hasFree, freeTaxMessage }: ParsePriceProps) => string;
+export declare const getDiscountPercent: (listPrice: number, price: number) => number;

package/data/helpers/product/skuInfos.d.ts

@@ -0,0 +1,21 @@
+import { HasVariant } from '../../../types/global/product';
+import { Sizes } from '../../../types/contexts/contexts/pdp';
+import { GetSkuInfosProps } from '../../../types/data/helpers';
+
+export declare const getSkuInfos: ({ items, NAME_SPLIT_SYMBOL }: GetSkuInfosProps) => {
+    sizes: Sizes;
+    allSizesAvailable: boolean;
+    price: number;
+    listPrice: number;
+    installments: import('../../../types/contexts/contexts/pdp').Installments;
+};
+export declare const disableSKU: (item: HasVariant) => boolean;
+export declare const getValidOffer: (offers: HasVariant["offers"]["offers"], mainSellerId: string) => {
+    listPrice: number;
+    price: number;
+    availability: string;
+    quantity?: number;
+    seller: {
+        identifier: string;
+    };
+} | undefined;

package/data/helpers/product/thumb.d.ts

@@ -0,0 +1,3 @@
+import { GetThumbImageProps } from '../../../types/data/helpers';
+
+export declare const getThumbImage: ({ images, TEXTURE_IMAGE }: GetThumbImageProps) => import('../../../types/global/product').ImageType;