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

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/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,9 @@
+import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+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;
+export declare const navigateToSearchPage: (router: AppRouterInstance, query?: string, count?: number, page?: number, sort?: string) => void;

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

@@ -0,0 +1,4 @@
+export declare function fetchCMS(url: URL, params?: Record<string, unknown>, previewMode?: boolean): Promise<Response>;
+export declare function createUrl(contentType: string, params: Record<string, unknown>): string;
+export declare function spreadStrapiData<T>(data: T): T | null;
+export declare function mergePreviewDocument<T>(contentType: string, documents?: T[], params?: Record<string, unknown>): Promise<any[]>;

package/data/helpers/utils/cookies.d.ts

@@ -0,0 +1,2 @@
+export declare function getCookie(name: string): string | undefined;
+export declare function setCookie(name: string, value?: string, options?: {}): void;

package/data/helpers/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce(cb: Function, delay?: number): (...args: any[]) => void;

package/data/helpers/utils/generateSlug.d.ts

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

package/data/helpers/utils/getAltTextFromUrl.d.ts

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

package/data/helpers/utils/getAuthenticatedUser.d.ts

@@ -0,0 +1,4 @@
+export declare const getAuthenticatedUser: (token: string) => {
+    email: string | undefined;
+    userId: unknown;
+};

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

@@ -0,0 +1,8 @@
+export * from './cookies';
+export * from './generateSlug';
+export * from './throttle';
+export * from './debounce';
+export * from './timer';
+export * from './getAuthenticatedUser';
+export * from './inputValidation';
+export * from './getAltTextFromUrl';

package/data/helpers/utils/inputValidation.d.ts

@@ -0,0 +1,7 @@
+export declare const FieldTypes: readonly ["name", "email", "phone", "date", "cpf", "cep"];
+export type FieldType = (typeof FieldTypes)[number] | string;
+export declare const validateInput: ({ type, input, required, }: {
+    type: FieldType;
+    input: FormDataEntryValue;
+    required?: boolean;
+}) => boolean;

package/data/helpers/utils/stringToSHA1.d.ts

@@ -0,0 +1 @@
+export declare function stringToSHA1(string: string): Promise<string>;

package/data/helpers/utils/throttle.d.ts

@@ -0,0 +1 @@
+export declare function throttle(cb: Function, delay?: number): (...args: any[]) => void;

package/data/helpers/utils/timer.d.ts

@@ -0,0 +1,2 @@
+export declare const getMilliSeconds: (dateInit: Date, dateEnd: Date) => number;
+export declare const getDaysHoursMinutesSeconds: (milliseconds: number, type?: string) => number;

package/data/index.d.ts

@@ -0,0 +1,14 @@
+import * as cart from "./helpers/cart";
+import * as events from "./helpers/events";
+import * as plp from "./helpers/plp";
+import * as product from "./helpers/product";
+import * as utils from "./helpers/utils";
+export declare const data: {
+    helpers: {
+        cart: typeof cart;
+        events: typeof events;
+        plp: typeof plp;
+        product: typeof product;
+        utils: typeof utils;
+    };
+};