@soma-vertical-web/multi-lib 0.0.32 → 0.0.34

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

@@ -0,0 +1,279 @@
+import { SearchCreatePages, SearchCreateProduct } from '../../../../types/data/helpers';
+import { ProductType_APISearch, EnhancedSku_APISearch, ProductNode_PDC } from '../../../../types/global/product';
+import { Page } from '../../../../types/contexts/contexts/plp';
+
+export declare const getInstallments: (installments: EnhancedSku_APISearch["sellers"][0]["commertialOffer"]["Installments"]) => {
+    count: number;
+    value: number;
+};
+export declare const getOffers: (sellers: EnhancedSku_APISearch["sellers"], product: ProductType_APISearch) => {
+    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;
+        };
+    }[];
+};
+export declare const getHasVariant: (item: ProductType_APISearch["items"][0]) => {
+    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";
+    })[];
+    name: string;
+    offers: {
+        offers: {
+            availability: string;
+            listPrice: number;
+            price: number;
+            quantity: number;
+            seller: {
+                identifier: string;
+            };
+        }[];
+    };
+    sku: string;
+};
+export declare const formattedProduct: (item: EnhancedSku_APISearch) => {
+    sku: string;
+    gtin: string;
+    name: string;
+    description: string;
+    releaseDate: string;
+    slug: string;
+    video: string;
+    categories: string[];
+    categoriesIds: string[];
+    id: string;
+    brand: {
+        name: string;
+        brandName: string;
+    };
+    seo: {
+        description: string;
+        title: string;
+        canonical: string;
+    };
+    cluster: {
+        generals: Record<string, string>;
+        highlights: Record<string, any>;
+    };
+    properties: {
+        name: string;
+        values: string[];
+    }[];
+    availability: {
+        status: boolean;
+    };
+    breadcrumbList: {
+        itemListElement: {
+            name: string;
+            item: string;
+            position: number;
+        }[];
+        numberOfItems: number;
+    };
+    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: string;
+        hasVariant: {
+            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";
+            })[];
+            name: string;
+            offers: {
+                offers: {
+                    availability: string;
+                    listPrice: number;
+                    price: number;
+                    quantity: number;
+                    seller: {
+                        identifier: string;
+                    };
+                }[];
+            };
+            sku: string;
+        }[];
+    };
+    installments: {
+        count: number;
+        value: number;
+    };
+};
+export declare const formattedRecommendationProduct: (item: any) => {
+    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;
+    };
+};
+export declare const createProduct: ({ MAIN_IMAGE, TEXTURE_IMAGE }: SearchCreateProduct) => ProductNode_PDC;
+export declare const createPages: ({ page, count, ...props }: SearchCreatePages) => {
+    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;
+};

package/data/helpers/search/product/utils/canonical.d.ts

@@ -0,0 +1 @@
+export declare const canonicalPDPLink: (linkText: string) => string;

package/data/helpers/search/product/utils/enhanceSku.d.ts

@@ -0,0 +1,9 @@
+import { CommertialOfferType, EnhancedCommercialOffer_APISearch, EnhancedSku_APISearch, ItemType_APISearch, ProductType_APISearch } from '../../../../../types/global/product';
+
+export declare const sanitizeProduct: (product: ProductType_APISearch) => ProductType_APISearch;
+export declare const enhanceCommercialOffer: <S, P>({ offer, seller, product, }: {
+    offer: CommertialOfferType;
+    seller: S;
+    product: P;
+}) => EnhancedCommercialOffer_APISearch<S, P>;
+export declare const enhanceSku: (item: ItemType_APISearch, product: ProductType_APISearch) => EnhancedSku_APISearch;

package/data/helpers/search/product/utils/images.d.ts

@@ -0,0 +1,7 @@
+import { ImageType } from '../../../../../types/global/product';
+
+export declare const getImages: (images: ImageType[]) => {
+    alternateName: string;
+    url: string;
+    keywords: string;
+}[];

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

@@ -0,0 +1,8 @@
+export * from './canonical';
+export * from './enhanceSku';
+export * from './images';
+export * from './productStock';
+export * from './propertyValue';
+export * from './sanitizeHtml';
+export * from './sku';
+export * from './slugify';

package/data/helpers/search/product/utils/productStock.d.ts

@@ -0,0 +1,7 @@
+import { CommertialOfferType } from '../../../../../types/global/product';
+
+export declare const availability: (available: boolean) => "https://schema.org/OutOfStock" | "https://schema.org/InStock";
+export declare const inStock: (offer: Pick<CommertialOfferType, "AvailableQuantity">) => boolean;
+export declare const price: (offer: Pick<CommertialOfferType, "spotPrice">) => number;
+export declare const sellingPrice: (offer: CommertialOfferType) => number;
+export declare const bestOfferFirst: (a: Pick<CommertialOfferType, "AvailableQuantity" | "spotPrice">, b: Pick<CommertialOfferType, "AvailableQuantity" | "spotPrice">) => number;

package/data/helpers/search/product/utils/propertyValue.d.ts

@@ -0,0 +1,20 @@
+import { Attachment } from '../../../../../types/data/api/search/product';
+import { ItemType_APISearch } from '../../../../../types/global/product';
+
+export declare const additionalProperty: (variations: ItemType_APISearch["variations"], attributes: ItemType_APISearch["attributes"], attachments?: Attachment[]) => ({
+    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";
+})[];

package/data/helpers/search/product/utils/sanitizeHtml.d.ts

@@ -0,0 +1,18 @@
+import { default as sanitizeHtmlLib } from 'sanitize-html';
+
+/**
+ * For now, we're using sanitize-html's default set
+ * of allowed tags and attributes, which don't even include img elements
+ *
+ * It is known many client depends on pontentially vulnerable tags, such as script tags
+ * We chose to be restrictive at first, and document those restrictions later.
+ *
+ * When expanding the set of allowed tags and attributes, please consider performance, privacy and security.
+ *
+ * This possibily breaks compatibility with Portal and Store Framework,
+ * which both allows an enormous amount of tags and attributes
+ *
+ * This was a thoughtful decision that can be reviewed in the future given
+ * research was made to back up those changes.
+ */
+export declare const sanitizeHtml: (dirty: Parameters<typeof sanitizeHtmlLib>[0], options?: Parameters<typeof sanitizeHtmlLib>[1]) => string;

package/data/helpers/search/product/utils/sku.d.ts

@@ -0,0 +1,5 @@
+import { ItemType_APISearch } from '../../../../../types/global/product';
+
+export declare const min: <T>(array: T[], cmp: (a: T, b: T) => number) => T;
+export declare const isValidSkuId: (skuId: string) => boolean;
+export declare const pickBestSku: (skus: ItemType_APISearch[]) => ItemType_APISearch;

package/data/helpers/search/product/utils/slugify.d.ts

@@ -0,0 +1 @@
+export declare const slugify: (str: string) => string;

package/data/helpers/search/root.d.ts

@@ -0,0 +1,11 @@
+import { Facet, FacetValueBoolean, SelectedFacet } from '../../../types/data/api/search/facets';
+
+export declare const POLICY_KEY = "trade-policy";
+export declare const REGION_KEY = "region-id";
+export declare const FUZZY_KEY = "fuzzy";
+export declare const OPERATOR_KEY = "operator";
+export declare const EXTRA_FACETS_KEYS: Set<string>;
+export declare const isCategoryBrand: (selectedFacets: SelectedFacet[]) => {
+    isDepartment: boolean;
+};
+export declare const filterNonCategorySelected: (facets: Facet[], base?: string | null) => Facet<FacetValueBoolean | import('../../../types/data/api/search/facets').FacetValueRange>[];

package/data/helpers/search/search.d.ts

@@ -0,0 +1,7 @@
+import { State } from '../../../types/data/api/search';
+
+export declare const parseSearchState: ({ pathname, searchParams }: URL, facets: string[]) => State;
+export declare const createCategorySlug: (slug: string[] | string, facets: string[]) => string;
+export declare const convertSearchParams: (searchParams: {
+    [key: string]: string | string[] | undefined;
+}) => URLSearchParams;