@soma-vertical-web/multi-lib 0.0.31 → 0.0.33

package/__vite-browser-external-BYRIRx8p.mjs

@@ -0,0 +1,8 @@
+const e = {}, t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: e
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  t as _,
+  e as f
+};

package/__vite-browser-external-Cjz79hOw.js

@@ -0,0 +1 @@
+"use strict";const e={},t=Object.freeze(Object.defineProperty({__proto__:null,default:e},Symbol.toStringTag,{value:"Module"}));exports.__viteBrowserExternal=t;exports.fs=e;

package/data/api/cms/backup/index.d.ts

@@ -0,0 +1,11 @@
+import { GetContentTypeProps } from '../../../../types/data/api/cms';
+
+export declare function cmsBackup(props: GetContentTypeProps): Promise<{
+    success: boolean;
+    fileName: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: {};
+    fileName?: undefined;
+}>;

package/data/api/cms/content-type/index.d.ts

@@ -0,0 +1,3 @@
+import { GetCMSContentTypeProps } from '../../../../types/data/api/cms';
+
+export declare function getCMSContentType({ contentType, documentId, versionId, storeId, CMS_PROJECT_NAME, }: GetCMSContentTypeProps): Promise<Response>;

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

@@ -9,3 +9,5 @@ export declare function getContentType<T>({ contentType, NextCookies, CMS_PROJEC
     data: never[];
     error: unknown;
 }>;
+export * from './backup';
+export * from './content-type';

package/data/api/fetchVtex.d.ts

@@ -1,4 +1,5 @@
 import { FetchOptions } from '../../types/data/api';
 
-export declare const fetchVtexOrderForm: (url: string, options?: FetchOptions) => Promise<Record<string, any>>;
 export declare const fetchVtex: (url: string, options?: FetchOptions) => Promise<any>;
+export declare const fetchVtexOrderForm: (url: string, options?: FetchOptions) => Promise<Record<string, any>>;
+export declare function fetchVtexWithAbortController<T>(url: string, options?: FetchOptions): Promise<T | undefined>;

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

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

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

@@ -0,0 +1,95 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+import * as yup from 'yup';
+declare const schema: yup.ObjectSchema<{
+    facets: {
+        value: string;
+        key: string;
+    }[];
+}, yup.AnyObject, {
+    facets: "";
+}, "">;
+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/helpers/cms/index.d.ts

@@ -0,0 +1,11 @@
+import { GetContentTypeProps } from '../../../types/data/api/cms';
+
+export declare function backupContentType({ contentType, storeId, CMS_PROJECT_NAME, NextCookies }: GetContentTypeProps): Promise<{
+    success: boolean;
+    fileName: string;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: {};
+    fileName?: undefined;
+}>;

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

@@ -0,0 +1,48 @@
+import { Facet, FacetSearchResult, FacetValueBoolean, FacetValueRange, FuzzyFacet, OperatorFacet, SelectedFacet } from '../../../types/data/api/search/facets';
+import { Channel, StoreSelectedFacet } from '../../../types/data/api/search';
+import { CrossSellingFacet } from '../../../types/constants';
+
+export declare const isRootFacet: (facetKey: string, isDepartment: boolean) => boolean;
+export declare const isOperatorFacet: (facet: SelectedFacet) => facet is OperatorFacet;
+export declare const isFacetBoolean: (facet: Facet) => facet is Facet<FacetValueBoolean>;
+export declare const isCrossSelling: (x: string) => x is CrossSellingFacet["key"];
+export declare const findCrossSelling: (facets?: SelectedFacet[]) => CrossSellingFacet | null;
+export declare const findSlug: (facets?: SelectedFacet[]) => string | null;
+export declare const findSkuId: (facets?: SelectedFacet[]) => string | null;
+export declare const findLocale: (facets?: SelectedFacet[]) => string | null;
+export declare const findChannel: (facets?: SelectedFacet[]) => string | null;
+export declare const isFuzzyFacet: (facet: SelectedFacet) => facet is FuzzyFacet;
+export declare const facetBoolean: (item: Facet<FacetValueBoolean>) => {
+    __typename: string;
+    key: string;
+    label: string;
+    values: FacetValueBoolean[];
+};
+export declare const facetRange: ({ key, values }: Facet<FacetValueRange>) => {
+    __typename: string;
+    key: string;
+    values: FacetValueRange[];
+};
+export declare const formattedFacets: (data: FacetSearchResult, selectedFacets: SelectedFacet[], isCollectionPage?: any) => ({
+    __typename: string;
+    key: string;
+    label: string;
+    values: FacetValueBoolean[];
+} | {
+    __typename: string;
+    key: string;
+    values: FacetValueRange[];
+})[];
+export declare const addSearchParamsFacets: (facets: SelectedFacet[], params: URLSearchParams) => void;
+export declare const selectedFacets: (facets: string[]) => {
+    key: string;
+    value: string;
+}[];
+export declare const filterRootFacets: (selectedFacets: SelectedFacet[]) => SelectedFacet[];
+export declare const filterNonRootFacets: (selectedFacets: SelectedFacet[], base?: string | null) => {
+    value: string;
+    key: string;
+}[];
+export declare const addDefaultFacets: (facets: SelectedFacet[], channel: Channel, policy?: string, region?: string) => SelectedFacet[];
+export declare const getRegionFacet: (channel: Channel, region?: string) => StoreSelectedFacet | null;
+export declare const getPolicyFacet: (channel: Channel, key?: string) => StoreSelectedFacet | null;

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

@@ -0,0 +1,12 @@
+declare const searchHelpers: {
+    parseSearchState: ({ pathname, searchParams }: URL, facets: string[]) => import('../../../types/data/api/search').State;
+    convertSearchParams: (searchParams: {
+        [key: string]: string | string[] | undefined;
+    }) => URLSearchParams;
+    filterNonRootFacets: (selectedFacets: import('../../../types/data/api/search/facets').SelectedFacet[], base?: string | null) => {
+        value: string;
+        key: string;
+    }[];
+    filterNonCategorySelected: (facets: import('../../../types/data/api/search/facets').Facet[], base?: string | null) => import('../../../types/data/api/search/facets').Facet<import('../../../types/data/api/search/facets').FacetValueBoolean | import('../../../types/data/api/search/facets').FacetValueRange>[];
+};
+export default searchHelpers;

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;