@athoscommerce/snap-client 1.0.0

package/dist/esm/Client/apis/Recommend.d.ts

@@ -0,0 +1,15 @@
+import { API } from './Abstract';
+import { RecommendRequesterPaths } from '../../types';
+import { ProfileRequestModel, ProfileResponseModel, RecommendResponseModel, RecommendRequestModel, RecommendPostRequestModel } from '../../types';
+export declare class RecommendAPI extends API<RecommendRequesterPaths> {
+    private batches;
+    getProfile(queryParameters: ProfileRequestModel): Promise<ProfileResponseModel>;
+    batchRecommendations(parameters: RecommendRequestModel): Promise<RecommendResponseModel>;
+    postRecommendations(requestParameters: RecommendPostRequestModel): Promise<RecommendResponseModel[]>;
+}
+type DefinedProps = {
+    [key: string]: any;
+};
+export declare function defined(properties: Record<string, any>): DefinedProps;
+export {};
+//# sourceMappingURL=Recommend.d.ts.map

package/dist/esm/Client/apis/Recommend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Recommend.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Recommend.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAAiD,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGrG,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAsBlJ,qBAAa,YAAa,SAAQ,GAAG,CAAC,uBAAuB,CAAC;IAC7D,OAAO,CAAC,OAAO,CAMR;IAED,UAAU,CAAC,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAgB/E,oBAAoB,CAAC,UAAU,EAAE,qBAAqB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAuHxF,mBAAmB,CAAC,iBAAiB,EAAE,yBAAyB,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC;CAiB1G;AA2BD,KAAK,YAAY,GAAG;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB,CAAC;AAEF,wBAAgB,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,YAAY,CAUrE"}

package/dist/esm/Client/apis/Recommend.js

@@ -0,0 +1,172 @@
+import { API } from './Abstract';
+import { AppMode } from '@athoscommerce/snap-toolbox';
+import { transformRecommendationFiltersPost } from '../transforms';
+import { DEVELOPMENT_MODE_PARAM } from './Search';
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
+}
+const BATCH_TIMEOUT = 150;
+export class RecommendAPI extends API {
+    constructor() {
+        super(...arguments);
+        this.batches = {};
+    }
+    async getProfile(queryParameters) {
+        const headerParameters = {};
+        const response = await this.request({
+            path: this.configuration.paths.profile || '/v1/profile',
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, JSON.stringify(queryParameters));
+        return response;
+    }
+    async batchRecommendations(parameters) {
+        const batchId = parameters.batchId || 1;
+        // set up batch key and deferred promises
+        const key = parameters.batched ? `${parameters.profile?.siteId || parameters.siteId}:${batchId}` : `${Math.random()}:${batchId}`;
+        const batch = (this.batches[key] = this.batches[key] || { timeout: null, request: { profiles: [] }, entries: [] });
+        const deferred = new Deferred();
+        // add each request to the list
+        batch.entries.push({ request: parameters, deferred: deferred });
+        // wait for all of the requests to come in
+        const timeoutClear = typeof window !== 'undefined' ? window.clearTimeout : clearTimeout;
+        const timeoutSet = typeof window !== 'undefined' ? window.setTimeout : setTimeout;
+        timeoutClear && timeoutClear(batch.timeout);
+        batch.timeout = timeoutSet(async () => {
+            // delete the batch so a new one can take its place
+            delete this.batches[key];
+            // resort batch entries based on order
+            batch.entries.sort(sortBatchEntries);
+            // now that the requests are in proper order, map through them and build out the batches
+            batch.entries.map((entry) => {
+                // use products request only and combine when needed
+                if (entry.request.product) {
+                    if (Array.isArray(entry.request.products) && entry.request.products.indexOf(entry.request.product) == -1) {
+                        entry.request.products = entry.request.products.concat(entry.request.product);
+                    }
+                    else {
+                        entry.request.products = [entry.request.product];
+                    }
+                }
+                // build profile specific parameters
+                if (entry.request.profile) {
+                    const { tag, profile: { categories, brands, blockedItems, limit, query, filters, dedupe }, } = entry.request;
+                    const profile = {
+                        tag,
+                        ...defined({
+                            categories,
+                            brands,
+                            blockedItems,
+                            limit: limit,
+                            searchTerm: query,
+                            filters: transformRecommendationFiltersPost(filters),
+                            dedupe,
+                        }),
+                    };
+                    batch.request.profiles?.push(profile);
+                }
+                else {
+                    const { tag, categories, brands, limit, query, dedupe } = entry.request;
+                    const profile = {
+                        tag,
+                        ...defined({
+                            categories,
+                            brands,
+                            limit: limit,
+                            searchTerm: query,
+                            dedupe,
+                        }),
+                    };
+                    batch.request.profiles?.push(profile);
+                }
+                // parameters used globally
+                const { products, blockedItems, filters, test, cart, lastViewed, shopper } = entry.request;
+                // merge and de-dupe global array fields
+                const dedupedProducts = Array.from(new Set((batch.request.products || []).concat(products || [])));
+                const dedupedBlockedItems = Array.from(new Set((batch.request.blockedItems || []).concat(blockedItems || [])));
+                const dedupedFilters = Array.from(new Set((batch.request.filters || []).concat(transformRecommendationFiltersPost(filters) || []).map((filter) => JSON.stringify(filter)))).map((stringyFilter) => JSON.parse(stringyFilter));
+                batch.request = {
+                    ...batch.request,
+                    ...defined({
+                        siteId: entry.request.profile?.siteId || entry.request.siteId,
+                        products: dedupedProducts.length ? dedupedProducts : undefined,
+                        blockedItems: dedupedBlockedItems.length ? dedupedBlockedItems : undefined,
+                        filters: dedupedFilters.length ? dedupedFilters : undefined,
+                        test,
+                        cart,
+                        lastViewed,
+                        shopper,
+                    }),
+                };
+                if (this.configuration.mode == AppMode.development) {
+                    batch.request[DEVELOPMENT_MODE_PARAM] = true;
+                }
+            });
+            try {
+                if (this.configuration.mode == AppMode.development) {
+                    batch.request.test = true;
+                }
+                const response = await this.postRecommendations(batch.request);
+                batch.entries?.forEach((entry, index) => {
+                    entry.deferred.resolve(response[index]);
+                });
+            }
+            catch (err) {
+                batch.entries?.forEach((entry) => {
+                    entry.deferred.reject(err);
+                });
+            }
+        }, BATCH_TIMEOUT);
+        return deferred.promise;
+    }
+    async postRecommendations(requestParameters) {
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'text/plain';
+        const response = await this.request({
+            path: this.configuration.paths.recommend || '/v1/recommend',
+            method: 'POST',
+            headers: headerParameters,
+            body: requestParameters,
+            subDomain: 'p13n',
+        }, JSON.stringify(requestParameters));
+        return response;
+    }
+}
+function sortBatchEntries(a, b) {
+    const one = a.request;
+    const two = b.request;
+    const orderOne = one.order || one.profile?.order;
+    const orderTwo = two.order || two.profile?.order;
+    // undefined order goes last
+    if (orderOne == undefined && orderTwo == undefined) {
+        return 0;
+    }
+    if (orderOne == undefined && orderTwo != undefined) {
+        return 1;
+    }
+    if (orderTwo == undefined && orderOne != undefined) {
+        return -1;
+    }
+    if (orderOne < orderTwo) {
+        return -1;
+    }
+    if (orderOne > orderTwo) {
+        return 1;
+    }
+    return 0;
+}
+export function defined(properties) {
+    const definedProps = {};
+    Object.keys(properties).map((key) => {
+        if (properties[key] !== undefined) {
+            definedProps[key] = properties[key];
+        }
+    });
+    return definedProps;
+}

package/dist/esm/Client/apis/Search.d.ts

@@ -0,0 +1,12 @@
+import { AutocompleteRequestModel, AutocompleteResponseModel, SearchRequestModel, SearchResponseModel } from '@athoscommerce/snapi-types';
+import { API } from '.';
+import { SearchRequesterPaths } from '../../types';
+export declare const DEVELOPMENT_MODE_PARAM = "test";
+export declare class SearchAPI extends API<SearchRequesterPaths> {
+    private getEndpoint;
+    getAutocomplete(queryParameters: AutocompleteRequestModel): Promise<AutocompleteResponseModel>;
+    getSearch(queryParameters: SearchRequestModel): Promise<SearchResponseModel>;
+    getCategory(queryParameters: SearchRequestModel): Promise<SearchResponseModel>;
+    getFinder(queryParameters: SearchRequestModel): Promise<SearchResponseModel>;
+}
+//# sourceMappingURL=Search.d.ts.map

package/dist/esm/Client/apis/Search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Search.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAE1I,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAKnD,eAAO,MAAM,sBAAsB,SAAS,CAAC;AAE7C,qBAAa,SAAU,SAAQ,GAAG,CAAC,oBAAoB,CAAC;YACzC,WAAW;IA8BZ,eAAe,CAAC,eAAe,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAI9F,SAAS,CAAC,eAAe,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI5E,WAAW,CAAC,eAAe,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAI9E,SAAS,CAAC,eAAe,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAGzF"}

package/dist/esm/Client/apis/Search.js

@@ -0,0 +1,41 @@
+import { API } from '.';
+import { AppMode } from '@athoscommerce/snap-toolbox';
+import { transformSearchResponse } from '../transforms/searchResponse';
+import { transformSearchRequest } from '../transforms';
+export const DEVELOPMENT_MODE_PARAM = 'test';
+export class SearchAPI extends API {
+    async getEndpoint(requestParameters, path) {
+        const searchRequestParameters = transformSearchRequest(requestParameters);
+        searchRequestParameters.ajaxCatalog = this.configuration.initiator;
+        searchRequestParameters.resultsFormat = 'native';
+        if (this.configuration.mode == AppMode.development) {
+            searchRequestParameters[DEVELOPMENT_MODE_PARAM] = true;
+        }
+        // remove pageLoadId from cache key query params
+        const cacheParameters = { ...searchRequestParameters };
+        delete cacheParameters.pageLoadId;
+        delete cacheParameters.domain;
+        // autocomplete only params
+        delete cacheParameters.input;
+        delete cacheParameters.redirectResponse;
+        const searchResponse = await this.request({
+            path,
+            method: 'GET',
+            headers: {},
+            query: searchRequestParameters,
+        }, JSON.stringify(cacheParameters));
+        return transformSearchResponse(searchResponse, requestParameters);
+    }
+    async getAutocomplete(queryParameters) {
+        return this.getEndpoint(queryParameters, this.configuration.paths.autocomplete || '/v1/autocomplete');
+    }
+    async getSearch(queryParameters) {
+        return this.getEndpoint(queryParameters, this.configuration.paths.search || '/v1/search');
+    }
+    async getCategory(queryParameters) {
+        return this.getEndpoint(queryParameters, this.configuration.paths.category || '/v1/category');
+    }
+    async getFinder(queryParameters) {
+        return this.getEndpoint(queryParameters, this.configuration.paths.finder || '/v1/finder');
+    }
+}

package/dist/esm/Client/apis/Suggest.d.ts

@@ -0,0 +1,9 @@
+import { API } from './Abstract';
+import { SuggestRequesterPaths, SuggestRequestModel, SuggestResponseModel, TrendingRequestModel, TrendingResponseModel } from '../../types';
+export declare class SuggestAPI extends API<SuggestRequesterPaths> {
+    getSuggest(queryParameters: SuggestRequestModel): Promise<SuggestResponseModel>;
+    postSuggest(requestParameters: SuggestRequestModel): Promise<SuggestResponseModel>;
+    getTrending(queryParameters: TrendingRequestModel): Promise<TrendingResponseModel>;
+    postTrending(requestParameters: TrendingRequestModel): Promise<TrendingResponseModel>;
+}
+//# sourceMappingURL=Suggest.d.ts.map

package/dist/esm/Client/apis/Suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Suggest.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Suggest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,EAEN,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,MAAM,aAAa,CAAC;AAErB,qBAAa,UAAW,SAAQ,GAAG,CAAC,qBAAqB,CAAC;IACnD,UAAU,CAAC,eAAe,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAgB/E,WAAW,CAAC,iBAAiB,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiBlF,WAAW,CAAC,eAAe,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAgBlF,YAAY,CAAC,iBAAiB,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAgB3F"}

package/dist/esm/Client/apis/Suggest.js

@@ -0,0 +1,45 @@
+import { API } from './Abstract';
+export class SuggestAPI extends API {
+    async getSuggest(queryParameters) {
+        const headerParameters = {};
+        const response = await this.request({
+            path: this.configuration.paths.suggest || '/v1/suggest',
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, JSON.stringify(queryParameters));
+        return response;
+    }
+    async postSuggest(requestParameters) {
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        const response = await this.request({
+            path: this.configuration.paths.suggest || '/v1/suggest',
+            method: 'POST',
+            headers: headerParameters,
+            body: requestParameters,
+        }, JSON.stringify(requestParameters));
+        return response;
+    }
+    async getTrending(queryParameters) {
+        const headerParameters = {};
+        const response = await this.request({
+            path: this.configuration.paths.trending || '/v1/trending',
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, JSON.stringify(queryParameters));
+        return response;
+    }
+    async postTrending(requestParameters) {
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        const response = await this.request({
+            path: this.configuration.paths.trending || '/v1/trending',
+            method: 'POST',
+            headers: headerParameters,
+            body: requestParameters,
+        }, JSON.stringify(requestParameters));
+        return response;
+    }
+}

package/dist/esm/Client/apis/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Abstract';
+export * from './Search';
+export * from './Recommend';
+export * from './Suggest';
+export * from './Meta';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/Client/apis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC"}

package/dist/esm/Client/apis/index.js

@@ -0,0 +1,5 @@
+export * from './Abstract';
+export * from './Search';
+export * from './Recommend';
+export * from './Suggest';
+export * from './Meta';

package/dist/esm/Client/transforms/index.d.ts

@@ -0,0 +1,5 @@
+export * from './searchRequest';
+export * from './searchResponse';
+export * from './suggestResponse';
+export * from './recommendationFiltersPost';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/Client/transforms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Client/transforms/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC"}

package/dist/esm/Client/transforms/index.js

@@ -0,0 +1,4 @@
+export * from './searchRequest';
+export * from './searchResponse';
+export * from './suggestResponse';
+export * from './recommendationFiltersPost';

package/dist/esm/Client/transforms/recommendationFiltersPost.d.ts

@@ -0,0 +1,3 @@
+import { RecommendationRequestFilterModel, RecommendPostRequestFiltersModel } from '../../types';
+export declare const transformRecommendationFiltersPost: (filters?: RecommendationRequestFilterModel[]) => RecommendPostRequestFiltersModel[] | undefined;
+//# sourceMappingURL=recommendationFiltersPost.d.ts.map

package/dist/esm/Client/transforms/recommendationFiltersPost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommendationFiltersPost.d.ts","sourceRoot":"","sources":["../../../../src/Client/transforms/recommendationFiltersPost.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,gCAAgC,EAAE,MAAM,aAAa,CAAC;AAEjG,eAAO,MAAM,kCAAkC,aAAc,gCAAgC,EAAE,mDA0D9F,CAAC"}

package/dist/esm/Client/transforms/recommendationFiltersPost.js

@@ -0,0 +1,59 @@
+export const transformRecommendationFiltersPost = (filters) => {
+    if (!filters)
+        return;
+    const filterArray = [];
+    filters.map((filter) => {
+        if (filter.type == 'value') {
+            //check if filterArray contains a filter for this value already
+            const i = filterArray.findIndex((_filter) => _filter.field == filter.field);
+            if (i > -1) {
+                //if so just push another value to the already existing obj
+                filterArray[i].values.push(filter.value);
+            }
+            else {
+                //else create a new one
+                const val = {
+                    field: filter.field,
+                    type: '=',
+                    values: [filter.value],
+                };
+                filterArray.push(val);
+            }
+        }
+        else if (filter.type == 'range') {
+            //low
+            if (typeof filter.value.low == 'number') {
+                const low = {
+                    field: filter.field,
+                    type: '>=',
+                    values: [filter.value.low],
+                };
+                //dedupe
+                const i = filterArray.findIndex((_filter) => _filter.field == filter.field && _filter.type == '>=');
+                if (i > -1) {
+                    filterArray[i] = low;
+                }
+                else {
+                    filterArray.push(low);
+                }
+            }
+            //high
+            if (typeof filter.value.high == 'number') {
+                const high = {
+                    field: filter.field,
+                    type: '<=',
+                    values: [filter.value.high],
+                };
+                //dedupe
+                const i = filterArray.findIndex((_filter) => _filter.field == filter.field && _filter.type == '<=');
+                if (i > -1) {
+                    filterArray[i] = high;
+                }
+                else {
+                    filterArray.push(high);
+                }
+            }
+        }
+    });
+    return filterArray;
+};

package/dist/esm/Client/transforms/searchRequest.d.ts

@@ -0,0 +1,49 @@
+import { SearchRequestModel, SearchRequestModelSortsDirectionEnum, SearchRequestModelFilterRangeAllOfValue, AutocompleteRequestModel } from '@athoscommerce/snapi-types';
+export declare function transformSearchRequest(request: SearchRequestModel | AutocompleteRequestModel): any;
+export declare namespace transformSearchRequest {
+    var sorts: (request?: SearchRequestModel | AutocompleteRequestModel) => Record<string, SearchRequestModelSortsDirectionEnum[]>;
+    var search: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        q?: string;
+        rq?: string;
+        originalQuery?: string;
+        fallbackQuery?: string;
+        redirectResponse?: string;
+        source?: string;
+        input?: string;
+    };
+    var filters: (request?: SearchRequestModel | AutocompleteRequestModel) => Record<string, (string | number | SearchRequestModelFilterRangeAllOfValue | undefined)[]>;
+    var merchandising: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        disableMerchandising?: boolean;
+        tag?: string[];
+        'landing-page'?: string;
+        intellisuggest?: boolean;
+        disableInlineBanners?: boolean;
+    };
+    var pagination: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        page?: number;
+        resultsPerPage?: number;
+    };
+    var siteId: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        siteId: string;
+    } | {
+        siteId?: undefined;
+    };
+    var facets: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        includedFacets?: string[];
+        excludedFacets?: string[];
+        disableFacetDrillDown?: boolean;
+    };
+    var tracking: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        userId?: string;
+        domain?: string;
+        sessionId?: string;
+        pageLoadId?: string;
+    };
+    var personalization: (request?: SearchRequestModel | AutocompleteRequestModel) => {
+        skipPersonalization?: boolean;
+        cart?: string;
+        shopper?: string;
+        lastViewed?: string;
+    };
+}
+//# sourceMappingURL=searchRequest.d.ts.map

package/dist/esm/Client/transforms/searchRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchRequest.d.ts","sourceRoot":"","sources":["../../../../src/Client/transforms/searchRequest.ts"],"names":[],"mappings":"AACA,OAAO,EACN,kBAAkB,EAIlB,oCAAoC,EACpC,uCAAuC,EACvC,wBAAwB,EAExB,MAAM,4BAA4B,CAAC;AAEpC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,GAAG,wBAAwB,GAAG,GAAG,CAclG;yBAde,sBAAsB;0BAgBG,kBAAkB,GAAG,wBAAwB;2BAa5C,kBAAkB,GAAG,wBAAwB;YAGjF,MAAM;aACL,MAAM;wBACK,MAAM;wBACN,MAAM;2BACH,MAAM;iBAChB,MAAM;gBACP,MAAM;;4BAoC2B,kBAAkB,GAAG,wBAAwB;kCAmCvC,kBAAkB,GAAG,wBAAwB;+BAIrE,OAAO;cACxB,MAAM,EAAE;yBACG,MAAM;yBACN,OAAO;+BACD,OAAO;;+BAoBc,kBAAkB,GAAG,wBAAwB;eAGlF,MAAM;yBACI,MAAM;;2BAciB,kBAAkB,GAAG,wBAAwB;;;;;2BAQ7C,kBAAkB,GAAG,wBAAwB;yBAGpE,MAAM,EAAE;yBACR,MAAM,EAAE;gCACD,OAAO;;6BAsBW,kBAAkB,GAAG,wBAAwB;iBAG9E,MAAM;iBACN,MAAM;oBACH,MAAM;qBACL,MAAM;;oCAmB8B,kBAAkB,GAAG,wBAAwB;8BAGxE,OAAO;eACtB,MAAM;kBACH,MAAM;qBACH,MAAM"}

package/dist/esm/Client/transforms/searchRequest.js

@@ -0,0 +1,152 @@
+import { mergeParams } from '../utils';
+export function transformSearchRequest(request) {
+    const data = mergeParams(transformSearchRequest.sorts(request), transformSearchRequest.search(request), transformSearchRequest.filters(request), transformSearchRequest.merchandising(request), transformSearchRequest.pagination(request), transformSearchRequest.siteId(request), transformSearchRequest.facets(request), transformSearchRequest.tracking(request), transformSearchRequest.personalization(request));
+    return data;
+}
+transformSearchRequest.sorts = (request = {}) => {
+    return (request.sorts || []).reduce((acc, sort) => {
+        if (!sort.field || !sort.direction || (sort.direction != 'asc' && sort.direction != 'desc')) {
+            return acc;
+        }
+        return {
+            ...acc,
+            ['sort.' + sort.field]: (acc[sort.field] || []).concat([sort.direction]),
+        };
+    }, {});
+};
+transformSearchRequest.search = (request = {}) => {
+    const reqSearch = request.search || {};
+    const search = {};
+    if (reqSearch.query && reqSearch.query.string) {
+        search.q = reqSearch.query.string;
+    }
+    if (reqSearch.subQuery) {
+        search.rq = reqSearch.subQuery.trim();
+    }
+    if (reqSearch.originalQuery) {
+        search.originalQuery = reqSearch.originalQuery.trim();
+    }
+    if (reqSearch.fallbackQuery) {
+        search.fallbackQuery = reqSearch.fallbackQuery.trim();
+    }
+    if (reqSearch.redirectResponse) {
+        search.redirectResponse = reqSearch.redirectResponse;
+    }
+    // for autocomplete only
+    if (reqSearch.source) {
+        search.source = reqSearch.source;
+    }
+    // for autocomplete only
+    if (reqSearch.input) {
+        search.input = reqSearch.input;
+    }
+    return search;
+};
+transformSearchRequest.filters = (request = {}) => {
+    return (request.filters || []).reduce((acc, filter) => {
+        const baseKey = filter.background ? 'bgfilter' : 'filter';
+        if (filter.type == 'value') {
+            const key = baseKey + '.' + filter.field;
+            return {
+                ...acc,
+                [key]: (acc[key] || []).concat([filter.value]),
+            };
+        }
+        else if (filter.type == 'range') {
+            const keyLow = baseKey + '.' + filter.field + '.low';
+            const keyHigh = baseKey + '.' + filter.field + '.high';
+            const low = filter?.value?.low ?? '*';
+            const high = filter?.value?.high ?? '*';
+            return {
+                ...acc,
+                [keyLow]: (acc[keyLow] || []).concat([low]),
+                [keyHigh]: (acc[keyHigh] || []).concat([high]),
+            };
+        }
+        return acc;
+    }, {});
+};
+transformSearchRequest.merchandising = (request = {}) => {
+    const reqMerch = request.merchandising || {};
+    const merch = reqMerch.disabled ? { disableMerchandising: true } : {};
+    if (reqMerch.landingPage) {
+        merch['landing-page'] = reqMerch.landingPage;
+    }
+    if (reqMerch.segments instanceof Array && reqMerch.segments.length) {
+        merch['tag'] = reqMerch.segments.map((segment) => {
+            return `merch.segment/${segment}`;
+        });
+    }
+    if (reqMerch.disableInlineBanners) {
+        merch['disableInlineBanners'] = reqMerch.disableInlineBanners;
+    }
+    return merch;
+};
+transformSearchRequest.pagination = (request = {}) => {
+    const pagination = request.pagination || {};
+    const params = {};
+    if (pagination.page) {
+        params.page = pagination.page;
+    }
+    if (pagination.pageSize || pagination.pageSize === 0) {
+        params.resultsPerPage = pagination.pageSize;
+    }
+    return params;
+};
+transformSearchRequest.siteId = (request = {}) => {
+    if (request.siteId) {
+        return { siteId: request.siteId };
+    }
+    return {};
+};
+transformSearchRequest.facets = (request = {}) => {
+    const facets = request.facets || {};
+    const params = {};
+    if (facets.include && facets.include.length && facets.exclude && facets.exclude.length) {
+        throw 'cannot use facet include and exclude at the same time';
+    }
+    if (facets.include?.length) {
+        params.includedFacets = facets.include;
+    }
+    if (facets.exclude?.length) {
+        params.excludedFacets = facets.exclude;
+    }
+    if (facets.autoDrillDown === false) {
+        params.disableFacetDrillDown = true;
+    }
+    return params;
+};
+transformSearchRequest.tracking = (request = {}) => {
+    const reqTracking = request.tracking || {};
+    const params = {};
+    if (reqTracking.userId) {
+        params.userId = reqTracking.userId;
+    }
+    if (reqTracking.domain) {
+        params.domain = reqTracking.domain;
+    }
+    if (reqTracking.sessionId) {
+        params.sessionId = reqTracking.sessionId;
+    }
+    if (reqTracking.pageLoadId) {
+        params.pageLoadId = reqTracking.pageLoadId;
+    }
+    return params;
+};
+transformSearchRequest.personalization = (request = {}) => {
+    const personalization = request.personalization || {};
+    const params = {};
+    if (personalization.disabled) {
+        params.skipPersonalization = personalization.disabled;
+    }
+    if (personalization.cart) {
+        params.cart = personalization.cart;
+    }
+    if (personalization.lastViewed) {
+        params.lastViewed = personalization.lastViewed;
+    }
+    if (personalization.shopper) {
+        params.shopper = personalization.shopper;
+    }
+    return params;
+};