@searchspring/snap-client 0.20.0

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

@@ -0,0 +1,249 @@
+import { htmlUnescape } from '../utils/htmlUnescape';
+// TODO: Add all core fields
+const CORE_FIELDS = [
+    'uid',
+    'sku',
+    'name',
+    'url',
+    'addToCartUrl',
+    'price',
+    'msrp',
+    'imageUrl',
+    'secureImageUrl',
+    'thumbnailImageUrl',
+    'secureThumbnailImageUrl',
+    'rating',
+    'ratingCount',
+    'description',
+    'stockMessage',
+    'brand',
+    'popularity',
+    'caption',
+];
+class Result {
+    constructor(result) {
+        Object.assign(this, result);
+    }
+}
+export function transformSearchResponse(response, request) {
+    return {
+        ...transformSearchResponse.pagination(response),
+        ...transformSearchResponse.results(response),
+        ...transformSearchResponse.filters(response),
+        ...transformSearchResponse.facets(response, request),
+        ...transformSearchResponse.sorting(response),
+        ...transformSearchResponse.merchandising(response),
+        ...transformSearchResponse.search(response, request),
+    };
+}
+transformSearchResponse.pagination = (response) => {
+    const pagination = (response || {}).pagination || {};
+    return {
+        pagination: {
+            totalResults: pagination.totalResults,
+            page: pagination.currentPage,
+            pageSize: pagination.perPage,
+            defaultPageSize: pagination.defaultPerPage,
+            totalPages: pagination.totalPages,
+        },
+    };
+};
+transformSearchResponse.results = (response) => {
+    const results = (response || {}).results || [];
+    return { results: results.map(transformSearchResponse.result) };
+};
+transformSearchResponse.result = (rawResult) => {
+    const coreFieldValues = CORE_FIELDS.reduce((coreFields, key) => {
+        if (typeof rawResult[key] != 'undefined') {
+            return {
+                ...coreFields,
+                [key]: decodeProperty(rawResult[key]),
+            };
+        }
+        return coreFields;
+    }, {});
+    if (coreFieldValues.price)
+        coreFieldValues.price = +coreFieldValues.price;
+    if (coreFieldValues.msrp)
+        coreFieldValues.msrp = +coreFieldValues.msrp;
+    const attributes = Object.keys(rawResult)
+        .filter((k) => CORE_FIELDS.indexOf(k) == -1)
+        .reduce((attributes, key) => {
+        return {
+            ...attributes,
+            [key]: decodeProperty(rawResult[key]),
+        };
+    }, {});
+    const children = rawResult?.children?.map((child) => {
+        return {
+            attributes: {
+                ...Object.keys(child).reduce((attributes, key) => {
+                    return {
+                        ...attributes,
+                        [key]: decodeProperty(child[key]),
+                    };
+                }, {}),
+            },
+        };
+    }) || [];
+    return new Result({
+        id: rawResult.uid,
+        mappings: {
+            core: coreFieldValues,
+        },
+        attributes,
+        children,
+    });
+};
+transformSearchResponse.filters = (response) => {
+    const filterSummary = (response || {}).filterSummary || [];
+    return {
+        filters: filterSummary.map((filter) => {
+            let value = filter.value;
+            let type = 'value';
+            if (typeof filter.value == 'object') {
+                (type = 'range'),
+                    (value = {
+                        low: +filter.value.rangeLow,
+                        high: +filter.value.rangeHigh,
+                    });
+            }
+            return {
+                type,
+                field: filter.field,
+                label: filter.filterValue,
+                value,
+            };
+        }),
+    };
+};
+transformSearchResponse.facets = (response, request = {}) => {
+    const filters = request.filters || [];
+    const facets = (response || {}).facets || [];
+    return {
+        facets: facets.map((facet) => {
+            let transformedFacet = {
+                field: facet.field,
+                type: 'value',
+                filtered: Boolean(facet.facet_active),
+            };
+            if (facet.step) {
+                transformedFacet = {
+                    ...transformedFacet,
+                    type: 'range',
+                    step: facet.step,
+                    range: {
+                        low: facet.range[0] == '*' ? null : +facet.range[0],
+                        high: facet.range[1] == '*' ? null : +facet.range[1],
+                    },
+                };
+                if (facet.active && facet.active.length > 1) {
+                    transformedFacet.active = {
+                        low: facet.active[0] == '*' ? null : +facet.active[0],
+                        high: facet.active[1] == '*' ? null : +facet.active[1],
+                    };
+                }
+            }
+            else if (facet.values instanceof Array) {
+                if (facet.type == 'hierarchy') {
+                    transformedFacet.type = 'value';
+                    transformedFacet.values = (facet.values || []).map((value) => {
+                        return {
+                            filtered: Boolean(value.active),
+                            value: value.value,
+                            label: value.label,
+                            count: value.count,
+                        };
+                    });
+                    const filterSelected = filters.find((f) => f.field == facet.field);
+                    const newValues = [];
+                    if (filterSelected && !filterSelected.background) {
+                        const valueLevels = filterSelected.value.split(facet.hierarchyDelimiter);
+                        for (let i = valueLevels.length - 1; i >= 0; i--) {
+                            const valueSplit = valueLevels.slice(0, i + 1);
+                            const value = valueSplit.join(facet.hierarchyDelimiter);
+                            newValues.unshift({
+                                value,
+                                filtered: value == filterSelected.value,
+                                label: valueSplit[valueSplit.length - 1],
+                            });
+                        }
+                        newValues.unshift({
+                            value: null,
+                            filtered: false,
+                            label: 'View All',
+                        });
+                    }
+                    transformedFacet.values = newValues.concat(transformedFacet.values);
+                }
+                else if (facet.values[0].type == 'value') {
+                    transformedFacet.type = 'value';
+                    transformedFacet.values = facet.values.map((value) => {
+                        return {
+                            filtered: value.active,
+                            value: value.value,
+                            label: value.label,
+                            count: value.count,
+                        };
+                    });
+                }
+                else if (facet.values[0].type == 'range') {
+                    transformedFacet.type = 'range-buckets';
+                    transformedFacet.values = facet.values.map((value) => {
+                        return {
+                            filtered: value.active,
+                            low: value.low == '*' ? null : +value.low,
+                            high: value.high == '*' ? null : +value.high,
+                            label: value.label,
+                            count: value.count,
+                        };
+                    });
+                }
+            }
+            return transformedFacet;
+        }),
+    };
+};
+transformSearchResponse.sorting = (response) => {
+    const sorts = ((response || {}).sorting || {}).options || [];
+    const transformedSorting = sorts
+        .filter((sort) => sort.active)
+        .map((sort) => {
+        return {
+            field: sort.field,
+            direction: sort.direction,
+        };
+    });
+    return {
+        sorting: transformedSorting,
+    };
+};
+transformSearchResponse.merchandising = (response) => {
+    const merchandising = (response || {}).merchandising || {};
+    if (merchandising.content && Array.isArray(merchandising.content) && !merchandising.content.length) {
+        merchandising.content = {};
+    }
+    return {
+        merchandising,
+    };
+};
+transformSearchResponse.search = (response, request) => {
+    const didYouMean = ((response || {}).didYouMean || {}).query;
+    const originalQuery = ((request || {}).search || {}).originalQuery;
+    return {
+        search: {
+            query: (((request || {}).search || {}).query || {}).string,
+            didYouMean,
+            originalQuery,
+        },
+    };
+};
+// used for HTML entities decoding
+function decodeProperty(encoded) {
+    if (Array.isArray(encoded)) {
+        return encoded.map((item) => htmlUnescape(String(item)));
+    }
+    else {
+        return htmlUnescape(String(encoded));
+    }
+}

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

@@ -0,0 +1,29 @@
+import { SuggestResponseModel } from '../apis';
+export declare function transformSuggestResponse(response: SuggestResponseModel): any;
+export declare namespace transformSuggestResponse {
+    var query: (response: SuggestResponseModel) => {
+        query?: undefined;
+    } | {
+        query: string;
+    };
+    var correctedQuery: (response: SuggestResponseModel) => {
+        correctedQuery?: undefined;
+    } | {
+        correctedQuery: string;
+    };
+    var suggested: (response: SuggestResponseModel) => {
+        suggested?: undefined;
+    } | {
+        suggested: {
+            text: string;
+            type: string;
+            source: string;
+        };
+    };
+    var alternatives: (response: SuggestResponseModel) => {
+        alternatives: {
+            text: string;
+        }[];
+    };
+}
+//# sourceMappingURL=suggestResponse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"suggestResponse.d.ts","sourceRoot":"","sources":["../../../../src/Client/transforms/suggestResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAC/C,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,GAAG,CAO5E;yBAPe,wBAAwB"}

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

@@ -0,0 +1,42 @@
+export function transformSuggestResponse(response) {
+    return {
+        ...transformSuggestResponse.query(response),
+        ...transformSuggestResponse.correctedQuery(response),
+        ...transformSuggestResponse.suggested(response),
+        ...transformSuggestResponse.alternatives(response),
+    };
+}
+transformSuggestResponse.query = (response) => {
+    if (!response?.query) {
+        return {};
+    }
+    return { query: response.query };
+};
+transformSuggestResponse.correctedQuery = (response) => {
+    if (typeof response != 'object' || !response['corrected-query']) {
+        return {};
+    }
+    return { correctedQuery: response['corrected-query'] };
+};
+transformSuggestResponse.suggested = (response) => {
+    if (typeof response != 'object' || !response.suggested || typeof response.suggested != 'object') {
+        return {};
+    }
+    return {
+        suggested: {
+            text: response.suggested?.text,
+            type: response.suggested?.type,
+            source: response.suggested?.source,
+        },
+    };
+};
+transformSuggestResponse.alternatives = (response) => {
+    const alternatives = response?.alternatives || [];
+    return {
+        alternatives: alternatives.map((alternative) => {
+            return {
+                text: alternative.text,
+            };
+        }),
+    };
+};

package/dist/esm/Client/utils/charsParams.d.ts

@@ -0,0 +1,3 @@
+import { ParameterObject } from '../../types';
+export declare function charsParams(params: ParameterObject): number;
+//# sourceMappingURL=charsParams.d.ts.map

package/dist/esm/Client/utils/charsParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charsParams.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/charsParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAqB3D"}

package/dist/esm/Client/utils/charsParams.js

@@ -0,0 +1,19 @@
+export function charsParams(params) {
+    if (typeof params != 'object') {
+        throw new Error('function requires an object');
+    }
+    const count = Object.keys(params).reduce((count, key) => {
+        const keyLength = key.length;
+        const value = params[key];
+        if (Array.isArray(value)) {
+            return (count +
+                value.reduce((length, val) => {
+                    return length + keyLength + 1 + ('' + val).length;
+                }, 0));
+        }
+        else {
+            return count + keyLength + 1 + ('' + value).length;
+        }
+    }, 1);
+    return count;
+}

package/dist/esm/Client/utils/fibonacci.d.ts

@@ -0,0 +1,2 @@
+export declare const fibonacci: (num: number) => number;
+//# sourceMappingURL=fibonacci.d.ts.map

package/dist/esm/Client/utils/fibonacci.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fibonacci.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/fibonacci.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,QAAS,MAAM,KAAG,MAavC,CAAC"}

package/dist/esm/Client/utils/fibonacci.js

@@ -0,0 +1,10 @@
+export const fibonacci = (num) => {
+    let a = 1, b = 0, temp;
+    while (num >= 0) {
+        temp = a;
+        a = a + b;
+        b = temp;
+        num--;
+    }
+    return b;
+};

package/dist/esm/Client/utils/hashParams.d.ts

@@ -0,0 +1,3 @@
+import { ParameterObject } from '../../types';
+export declare function hashParams(params: ParameterObject): string;
+//# sourceMappingURL=hashParams.d.ts.map

package/dist/esm/Client/utils/hashParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashParams.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/hashParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAM1D"}

package/dist/esm/Client/utils/hashParams.js

@@ -0,0 +1,6 @@
+export function hashParams(params) {
+    if (typeof params != 'object') {
+        throw new Error('function requires an object');
+    }
+    return JSON.stringify(params);
+}

package/dist/esm/Client/utils/htmlUnescape.d.ts

@@ -0,0 +1,2 @@
+export declare function htmlUnescape(value: string): string;
+//# sourceMappingURL=htmlUnescape.d.ts.map

package/dist/esm/Client/utils/htmlUnescape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlUnescape.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/htmlUnescape.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,UAOzC"}

package/dist/esm/Client/utils/htmlUnescape.js

@@ -0,0 +1,8 @@
+export function htmlUnescape(value) {
+    return value
+        .replace(/>/g, '>')
+        .replace(/&lt;/g, '<')
+        .replace(/&#0?39;/g, "'")
+        .replace(/&quot;/g, '"')
+        .replace(/&amp;/g, '&');
+}

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

@@ -0,0 +1,2 @@
+export * from './mergeParams';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1 @@
+export * from './mergeParams';

package/dist/esm/Client/utils/mergeParams.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeParams(...args: any[]): any;
+//# sourceMappingURL=mergeParams.d.ts.map

package/dist/esm/Client/utils/mergeParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeParams.d.ts","sourceRoot":"","sources":["../../../../src/Client/utils/mergeParams.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,GAAG,IAAI,OAAA,GAAG,GAAG,CAYxC"}

package/dist/esm/Client/utils/mergeParams.js

@@ -0,0 +1,10 @@
+export function mergeParams(...args) {
+    const ret = {};
+    args.reverse().forEach((params) => {
+        Object.keys(params).forEach((key) => {
+            const values = params[key] instanceof Array ? params[key] : [params[key]];
+            ret[key] = (ret[key] || []).concat(values);
+        });
+    });
+    return ret;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Client/Client';
+export { ClientGlobals, ClientConfig } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAEhC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './Client/Client';

package/dist/esm/types.d.ts

@@ -0,0 +1,45 @@
+export declare type ClientConfig = {
+    meta?: {
+        api?: SnapApiConfig;
+        cache?: CacheConfig;
+    };
+    search?: {
+        api?: SnapApiConfig;
+        cache?: CacheConfig;
+    };
+    autocomplete?: {
+        api?: SnapApiConfig;
+        cache?: CacheConfig;
+    };
+    recommend?: {
+        api?: SnapApiConfig;
+        cache?: CacheConfig;
+    };
+    suggest?: {
+        api?: SnapApiConfig;
+        cache?: CacheConfig;
+    };
+};
+export declare type CacheConfig = {
+    enabled?: boolean;
+    ttl?: number;
+    maxSize?: number;
+    purgeable?: boolean;
+};
+export declare type CacheEntry = {
+    value: Response;
+    expires?: number;
+    purgeable?: boolean;
+};
+export declare type Cache = {
+    [key: string]: CacheEntry;
+};
+export declare type SnapApiConfig = {
+    origin?: string;
+};
+export declare type ClientGlobals = {
+    siteId: string;
+    [configurationPath: string]: any;
+};
+export declare type ParameterObject = Record<string, boolean | string | string[] | number | number[]>;
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY,GAAG;IAC1B,IAAI,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,aAAa,CAAC;QACpB,KAAK,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;IACF,MAAM,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,aAAa,CAAC;QACpB,KAAK,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;IACF,YAAY,CAAC,EAAE;QACd,GAAG,CAAC,EAAE,aAAa,CAAC;QACpB,KAAK,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;IACF,SAAS,CAAC,EAAE;QACX,GAAG,CAAC,EAAE,aAAa,CAAC;QACpB,KAAK,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;IACF,OAAO,CAAC,EAAE;QACT,GAAG,CAAC,EAAE,aAAa,CAAC;QACpB,KAAK,CAAC,EAAE,WAAW,CAAC;KACpB,CAAC;CACF,CAAC;AAEF,oBAAY,WAAW,GAAG;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,oBAAY,UAAU,GAAG;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,oBAAY,KAAK,GAAG;IACnB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;CAC1B,CAAC;AAEF,oBAAY,aAAa,GAAG;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,oBAAY,aAAa,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,iBAAiB,EAAE,MAAM,GAAG,GAAG,CAAC;CACjC,CAAC;AAEF,oBAAY,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC"}

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@searchspring/snap-client",
+	"version": "0.20.0",
+	"description": "Snap Client",
+	"main": "dist/cjs/index.js",
+	"module": "dist/esm/index.js",
+	"author": "Searchspring",
+	"license": "MIT",
+	"repository": "https://github.com/searchspring/snap",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "rm -rf ./dist && tsc && tsc -p tsconfig.cjs.json",
+		"build:docs": "typedoc --out docs src/index.ts",
+		"dev": "tsc --watch",
+		"format": "prettier --write 'src/**/*.{js,jsx,ts,tsx}'",
+		"lint": "eslint 'src/**/*.{js,jsx,ts,tsx}'",
+		"test": "jest",
+		"test:watch": "jest --watch"
+	},
+	"sideEffects": false,
+	"files": [
+		"dist/**/*"
+	],
+	"gitHead": "122405b27b497c7bb6a189c30535fdc197bc3ef0"
+}