@searchspring/snap-client 0.20.0

package/dist/cjs/index.d.ts

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

package/dist/cjs/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/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Client/Client"), exports);

package/dist/cjs/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/cjs/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/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+import { TrendingRequestModel, TrendingResponseModel, RecommendCombinedRequestModel, RecommendCombinedResponseModel } from './apis';
+import type { ClientGlobals, ClientConfig } from '../types';
+import type { MetaRequestModel, MetaResponseModel, SearchRequestModel, SearchResponseModel, AutocompleteRequestModel, AutocompleteResponseModel } from '@searchspring/snapi-types';
+export declare class Client {
+    private globals;
+    private config;
+    private requesters;
+    constructor(globals: ClientGlobals, config?: ClientConfig);
+    meta(params?: MetaRequestModel): Promise<MetaResponseModel>;
+    autocomplete(params?: AutocompleteRequestModel): Promise<[MetaResponseModel, AutocompleteResponseModel]>;
+    search(params?: SearchRequestModel): Promise<[MetaResponseModel, SearchResponseModel]>;
+    trending(params: Partial<TrendingRequestModel>): Promise<TrendingResponseModel>;
+    recommend(params: RecommendCombinedRequestModel): Promise<RecommendCombinedResponseModel>;
+}
+//# sourceMappingURL=Client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../../src/Client/Client.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,oBAAoB,EACpB,qBAAqB,EAErB,6BAA6B,EAC7B,8BAA8B,EAG9B,MAAM,QAAQ,CAAC;AAEhB,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE5D,OAAO,KAAK,EACX,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,2BAA2B,CAAC;AAgCnC,qBAAa,MAAM;IAClB,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,UAAU,CAMhB;gBAEU,OAAO,EAAE,aAAa,EAAE,MAAM,GAAE,YAAiB;IA0CvD,IAAI,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAO3D,YAAY,CAAC,MAAM,GAAE,wBAA6B,GAAG,OAAO,CAAC,CAAC,iBAAiB,EAAE,yBAAyB,CAAC,CAAC;IAU5G,MAAM,CAAC,MAAM,GAAE,kBAAuB,GAAG,OAAO,CAAC,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;IAM1F,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAM/E,SAAS,CAAC,MAAM,EAAE,6BAA6B,GAAG,OAAO,CAAC,8BAA8B,CAAC;CAkC/F"}

package/dist/esm/Client/Client.js

@@ -0,0 +1,108 @@
+import { HybridAPI, SuggestAPI, RecommendAPI, ApiConfiguration, } from './apis';
+import deepmerge from 'deepmerge';
+const defaultConfig = {
+    meta: {
+        cache: {
+            purgeable: false,
+        },
+    },
+    search: {
+        api: {
+        // origin: 'https://snapi.kube.searchspring.io',
+        },
+    },
+    autocomplete: {
+        api: {
+        // origin: 'https://snapi.kube.searchspring.io',
+        },
+    },
+    recommend: {
+        api: {
+        // origin: 'https://snapi.kube.searchspring.io',
+        },
+    },
+    suggest: {
+        api: {
+        // origin: 'https://snapi.kube.searchspring.io',
+        },
+    },
+};
+export class Client {
+    constructor(globals, config = {}) {
+        if (!globals?.siteId) {
+            throw 'no siteId specified!';
+        }
+        this.globals = globals;
+        this.config = deepmerge(defaultConfig, config);
+        this.requesters = {
+            autocomplete: new HybridAPI(new ApiConfiguration({
+                origin: this.config.autocomplete?.api?.origin,
+                cacheSettings: this.config.autocomplete.cache,
+            })),
+            meta: new HybridAPI(new ApiConfiguration({
+                origin: this.config.meta?.api?.origin,
+                cacheSettings: this.config.meta.cache,
+            })),
+            recommend: new RecommendAPI(new ApiConfiguration({
+                origin: this.config.recommend?.api?.origin,
+                cacheSettings: this.config.recommend.cache,
+            })),
+            search: new HybridAPI(new ApiConfiguration({
+                origin: this.config.search?.api?.origin,
+                cacheSettings: this.config.search.cache,
+            })),
+            suggest: new SuggestAPI(new ApiConfiguration({
+                origin: this.config.suggest?.api?.origin,
+                cacheSettings: this.config.suggest.cache,
+            })),
+        };
+    }
+    async meta(params) {
+        const defaultParams = { siteId: this.globals.siteId };
+        params = deepmerge(defaultParams, params || {});
+        return this.requesters.meta.getMeta(params);
+    }
+    async autocomplete(params = {}) {
+        if (!params.search?.query?.string) {
+            throw 'query string parameter is required';
+        }
+        params = deepmerge(this.globals, params);
+        return Promise.all([this.meta({ siteId: params.siteId }), this.requesters.autocomplete.getAutocomplete(params)]);
+    }
+    async search(params = {}) {
+        params = deepmerge(this.globals, params);
+        return Promise.all([this.meta({ siteId: params.siteId }), this.requesters.search.getSearch(params)]);
+    }
+    async trending(params) {
+        params = deepmerge({ siteId: this.globals.siteId }, params || {});
+        return this.requesters.suggest.getTrending(params);
+    }
+    async recommend(params) {
+        // TODO - batching
+        const { tag, ...otherParams } = params;
+        if (!tag) {
+            throw 'tag parameter is required';
+        }
+        const profileParams = {
+            tag,
+            siteId: params.siteId || this.globals.siteId,
+        };
+        if (otherParams.branch) {
+            profileParams.branch = otherParams.branch;
+            delete otherParams.branch;
+        }
+        const recommendParams = {
+            tags: [tag],
+            siteId: params.siteId || this.globals.siteId,
+            ...otherParams,
+        };
+        const [profile, recommendations] = await Promise.all([
+            this.requesters.recommend.getProfile(profileParams),
+            this.requesters.recommend.batchRecommendations(recommendParams),
+        ]);
+        return {
+            ...profile,
+            results: recommendations[0].results,
+        };
+    }
+}

package/dist/esm/Client/NetworkCache/NetworkCache.d.ts

@@ -0,0 +1,10 @@
+import { CacheConfig } from '../../types';
+export declare class NetworkCache {
+    private memoryCache;
+    config: CacheConfig;
+    constructor(config?: CacheConfig);
+    get(key: string): Response;
+    set(key: string, value: Response): void;
+    clear(): void;
+}
+//# sourceMappingURL=NetworkCache.d.ts.map

package/dist/esm/Client/NetworkCache/NetworkCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkCache.d.ts","sourceRoot":"","sources":["../../../../src/Client/NetworkCache/NetworkCache.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAS,MAAM,aAAa,CAAC;AAWjD,qBAAa,YAAY;IACxB,OAAO,CAAC,WAAW,CAAa;IAChC,MAAM,EAAE,WAAW,CAAC;gBAER,MAAM,CAAC,EAAE,WAAW;IAIzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;IAgC1B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,IAAI;IAyCvC,KAAK;CAQZ"}

package/dist/esm/Client/NetworkCache/NetworkCache.js

@@ -0,0 +1,89 @@
+import deepmerge from 'deepmerge';
+const CACHE_STORAGE_KEY = 'ss-networkcache';
+const defaultConfig = {
+    enabled: true,
+    ttl: 300000,
+    maxSize: 200,
+    purgeable: true,
+};
+export class NetworkCache {
+    constructor(config) {
+        this.memoryCache = {};
+        this.config = deepmerge(defaultConfig, config || {});
+    }
+    get(key) {
+        try {
+            if (this.memoryCache[key]) {
+                if (Date.now() < this.memoryCache[key].expires) {
+                    return this.memoryCache[key].value;
+                }
+            }
+            const stored = sessionStorage.getItem(CACHE_STORAGE_KEY);
+            const localData = stored && JSON.parse(stored);
+            if (localData && key && localData[key]) {
+                // compare the expiry time of the item with the current time
+                if (Date.now() > localData[key].expires) {
+                    // remove item
+                    const newStored = {
+                        ...localData,
+                    };
+                    delete newStored[key];
+                    //update storage
+                    sessionStorage.setItem(CACHE_STORAGE_KEY, JSON.stringify(newStored));
+                    return undefined;
+                }
+                else {
+                    return localData[key].value;
+                }
+            }
+        }
+        catch (err) {
+            console.warn('something went wrong, browser might not have cookies enabled');
+        }
+    }
+    set(key, value) {
+        if (this.config.enabled) {
+            try {
+                const cacheObject = {
+                    value,
+                    expires: Date.now() + this.config.ttl,
+                    purgeable: this.config.purgeable,
+                };
+                this.memoryCache[key] = cacheObject;
+                const stored = sessionStorage.getItem(CACHE_STORAGE_KEY);
+                const newStored = {
+                    ...(stored && JSON.parse(stored)),
+                };
+                newStored[key] = cacheObject;
+                let size = new Blob([JSON.stringify(newStored)], { endings: 'native' }).size / 1024;
+                while (size > this.config.maxSize) {
+                    const oldestKey = Object.keys(newStored)
+                        .filter((key) => newStored[key].purgeable)
+                        .sort((a, b) => {
+                        return newStored[a].expires - newStored[b].expires;
+                    })[0];
+                    if (!oldestKey)
+                        break;
+                    delete newStored[oldestKey];
+                    // recalculate size after removing oldest
+                    size = new Blob([JSON.stringify(newStored)], { endings: 'native' }).size / 1024;
+                }
+                if (size < this.config.maxSize) {
+                    sessionStorage.setItem(CACHE_STORAGE_KEY, JSON.stringify(newStored));
+                }
+            }
+            catch (err) {
+                console.warn('something went wrong, browser might not have cookies enabled');
+            }
+        }
+    }
+    clear() {
+        try {
+            this.memoryCache = {};
+            sessionStorage.setItem(CACHE_STORAGE_KEY, '');
+        }
+        catch (err) {
+            console.warn('something went wrong, browser might not have cookies enabled');
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import { NetworkCache } from '../NetworkCache/NetworkCache';
+import { CacheConfig } from '../../types';
+export declare type Json = any;
+export declare type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export declare type HTTPHeaders = {
+    [key: string]: string;
+};
+export declare type HTTPQuery = {
+    [key: string]: string | number | null | boolean | Array<string | number | null | boolean> | HTTPQuery;
+};
+export declare type HTTPBody = Json | FormData | URLSearchParams;
+export interface RequestOpts {
+    path: string;
+    method: HTTPMethod;
+    headers: HTTPHeaders;
+    query?: HTTPQuery;
+    body?: HTTPBody;
+}
+export declare class API {
+    protected configuration: ApiConfiguration;
+    private retryDelay;
+    private retryCount;
+    cache: NetworkCache;
+    constructor(configuration: ApiConfiguration);
+    protected request(context: RequestOpts, cacheKey?: any): Promise<Response>;
+    private createFetchParams;
+    private fetchApi;
+}
+export declare type FetchAPI = WindowOrWorkerGlobalScope['fetch'];
+export interface ApiConfigurationParameters {
+    origin?: string;
+    fetchApi?: FetchAPI;
+    queryParamsStringify?: (params: HTTPQuery) => string;
+    headers?: HTTPHeaders;
+    maxRetry?: number;
+    cacheSettings?: CacheConfig;
+}
+export declare class ApiConfiguration {
+    private configuration;
+    constructor(configuration: ApiConfigurationParameters);
+    get cacheSettings(): CacheConfig;
+    get maxRetry(): number;
+    get origin(): string;
+    get fetchApi(): FetchAPI;
+    get queryParamsStringify(): (params: HTTPQuery) => string;
+    get headers(): HTTPHeaders | undefined;
+}
+export declare function querystring(params: HTTPQuery, prefix?: string): string;
+//# sourceMappingURL=Abstract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Abstract.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Abstract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI1C,oBAAY,IAAI,GAAG,GAAG,CAAC;AACvB,oBAAY,UAAU,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAC1F,oBAAY,WAAW,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AACpD,oBAAY,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,GAAG,SAAS,CAAA;CAAE,CAAC;AAClI,oBAAY,QAAQ,GAAG,IAAI,GAAG,QAAQ,GAAG,eAAe,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED,qBAAa,GAAG;IAMH,SAAS,CAAC,aAAa,EAAE,gBAAgB;IALrD,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,UAAU,CAAK;IAEhB,KAAK,EAAE,YAAY,CAAC;gBAEL,aAAa,EAAE,gBAAgB;cAIrC,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;IAmChF,OAAO,CAAC,iBAAiB;IA+BzB,OAAO,CAAC,QAAQ,CAId;CACF;AAED,oBAAY,QAAQ,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;AAE1D,MAAM,WAAW,0BAA0B;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,CAAC;IACrD,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,WAAW,CAAC;CAC5B;AAED,qBAAa,gBAAgB;IAChB,OAAO,CAAC,aAAa;gBAAb,aAAa,EAAE,0BAA0B;IAM7D,IAAI,aAAa,IAAI,WAAW,CAE/B;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,QAAQ,IAAI,QAAQ,CAEvB;IAED,IAAI,oBAAoB,IAAI,CAAC,MAAM,EAAE,SAAS,KAAK,MAAM,CAExD;IAED,IAAI,OAAO,IAAI,WAAW,GAAG,SAAS,CAErC;CACD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,SAAK,GAAG,MAAM,CAmBlE"}

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

@@ -0,0 +1,119 @@
+import { fibonacci } from '../utils/fibonacci';
+import { NetworkCache } from '../NetworkCache/NetworkCache';
+const isBlob = (value) => typeof Blob !== 'undefined' && value instanceof Blob;
+export class API {
+    constructor(configuration) {
+        this.configuration = configuration;
+        this.retryDelay = 1000;
+        this.retryCount = 1;
+        this.fetchApi = async (url, init) => {
+            const response = await this.configuration.fetchApi(url, init);
+            return response;
+        };
+        this.cache = new NetworkCache(configuration.cacheSettings);
+    }
+    async request(context, cacheKey) {
+        const { url, init } = this.createFetchParams(context);
+        if (cacheKey) {
+            const cachedResponse = this.cache.get(cacheKey);
+            if (cachedResponse) {
+                this.retryCount = 0; // reset count and delay incase rate limit occurs again before a page refresh
+                this.retryDelay = 1000;
+                return cachedResponse;
+            }
+        }
+        const response = await this.fetchApi(url, init);
+        const responseJSON = await response.json();
+        if (response.status >= 200 && response.status < 300) {
+            this.retryCount = 0; // reset count and delay incase rate limit occurs again before a page refresh
+            this.retryDelay = 1000;
+            if (cacheKey) {
+                // save in the cache before returning
+                this.cache.set(cacheKey, responseJSON);
+            }
+            return responseJSON;
+        }
+        else if (response.status == 429) {
+            if (this.retryCount < this.configuration.maxRetry) {
+                await new Promise((resolve) => setTimeout(resolve, this.retryDelay)); // delay retry
+                this.retryDelay = fibonacci(this.retryCount) * 1000;
+                this.retryCount++;
+                return await this.request(context, cacheKey);
+            }
+            else {
+                throw response.status;
+            }
+        }
+        throw response.status;
+    }
+    createFetchParams(context) {
+        // grab siteID out of context to generate apiHost fo URL
+        const siteId = context?.body?.siteId || context?.query?.siteId;
+        if (!siteId) {
+            throw new Error(`Request failed. Missing "siteId" parameter.`);
+        }
+        const siteIdHost = `https://${siteId}.a.searchspring.io`;
+        const origin = (this.configuration.origin || siteIdHost).replace(/\/$/, '');
+        let url = `${origin}/${context.path.replace(/^\//, '')}`;
+        if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+            // only add the querystring to the URL if there are query parameters.
+            url += '?' + this.configuration.queryParamsStringify(context.query);
+        }
+        const body = (typeof FormData !== 'undefined' && context.body instanceof FormData) || context.body instanceof URLSearchParams || isBlob(context.body)
+            ? context.body
+            : JSON.stringify(context.body);
+        const headers = Object.assign({}, this.configuration.headers, context.headers);
+        const init = {
+            method: context.method,
+            headers: headers,
+            body,
+        };
+        return { url, init };
+    }
+}
+export class ApiConfiguration {
+    constructor(configuration) {
+        this.configuration = configuration;
+        if (!configuration.maxRetry) {
+            this.configuration.maxRetry = 8;
+        }
+    }
+    get cacheSettings() {
+        return this.configuration.cacheSettings;
+    }
+    get maxRetry() {
+        return this.configuration.maxRetry;
+    }
+    get origin() {
+        return this.configuration.origin;
+    }
+    get fetchApi() {
+        return this.configuration.fetchApi || window.fetch.bind(window);
+    }
+    get queryParamsStringify() {
+        return this.configuration.queryParamsStringify || querystring;
+    }
+    get headers() {
+        return this.configuration.headers;
+    }
+}
+export function querystring(params, prefix = '') {
+    return Object.keys(params)
+        .map((key) => {
+        const fullKey = prefix + (prefix.length ? `[${key}]` : key);
+        const value = params[key];
+        if (value instanceof Array) {
+            const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+            return `${encodeURIComponent(fullKey)}=${multiValue}`;
+        }
+        if (value instanceof Date) {
+            return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+        }
+        if (value instanceof Object) {
+            return querystring(value, fullKey);
+        }
+        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+    })
+        .filter((part) => part.length > 0)
+        .join('&');
+}

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

@@ -0,0 +1,10 @@
+import { AutocompleteRequestModel, AutocompleteResponseModel, MetaRequestModel, MetaResponseModel, SearchRequestModel, SearchResponseModel } from '@searchspring/snapi-types';
+import { API, ApiConfiguration } from '.';
+export declare class HybridAPI extends API {
+    private requesters;
+    constructor(configuration: ApiConfiguration);
+    getMeta(requestParameters: MetaRequestModel): Promise<MetaResponseModel>;
+    getSearch(requestParameters: SearchRequestModel): Promise<SearchResponseModel>;
+    getAutocomplete(requestParameters: AutocompleteRequestModel): Promise<AutocompleteResponseModel>;
+}
+//# sourceMappingURL=Hybrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Hybrid.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Hybrid.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,GAAG,EAAsC,gBAAgB,EAA6C,MAAM,GAAG,CAAC;AAGzH,qBAAa,SAAU,SAAQ,GAAG;IACjC,OAAO,CAAC,UAAU,CAGhB;gBAEU,aAAa,EAAE,gBAAgB;IASrC,OAAO,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAKxE,SAAS,CAAC,iBAAiB,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAQ9E,eAAe,CAAC,iBAAiB,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;CAoCtG"}

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

@@ -0,0 +1,49 @@
+import { API, LegacyAPI, SuggestAPI, ApiConfiguration } from '.';
+import { transformSearchRequest, transformSearchResponse, transformSuggestResponse } from '../transforms';
+export class HybridAPI extends API {
+    constructor(configuration) {
+        super(configuration);
+        this.requesters = {
+            legacy: new LegacyAPI(new ApiConfiguration({ origin: configuration.origin, cacheSettings: this.configuration.cacheSettings })),
+            suggest: new SuggestAPI(new ApiConfiguration({ origin: configuration.origin, cacheSettings: this.configuration.cacheSettings })),
+        };
+    }
+    async getMeta(requestParameters) {
+        const legacyRequestParameters = requestParameters;
+        return this.requesters.legacy.getMeta(legacyRequestParameters);
+    }
+    async getSearch(requestParameters) {
+        const legacyRequestParameters = transformSearchRequest(requestParameters);
+        const legacyData = await this.requesters.legacy.getSearch(legacyRequestParameters);
+        return transformSearchResponse(legacyData, requestParameters);
+    }
+    async getAutocomplete(requestParameters) {
+        const legacyRequestParameters = transformSearchRequest(requestParameters);
+        const suggestParams = {
+            siteId: legacyRequestParameters.siteId,
+            language: 'en',
+            query: legacyRequestParameters.q,
+            suggestionCount: (requestParameters.suggestions || {}).count || 5,
+        };
+        if (!((requestParameters.search || {}).query || {}).spellCorrection) {
+            suggestParams.disableSpellCorrect = true;
+        }
+        const suggestResults = await this.requesters.suggest.getSuggest(suggestParams);
+        const transformedSuggestResults = transformSuggestResponse(suggestResults);
+        const q = (suggestResults.suggested || {}).text || transformedSuggestResults.correctedQuery || suggestResults.query;
+        const queryParameters = {
+            ...legacyRequestParameters,
+            redirectResponse: 'full',
+            q,
+        };
+        const legacyResults = await this.requesters.legacy.getAutocomplete(queryParameters);
+        const searchResults = transformSearchResponse(legacyResults, requestParameters);
+        return {
+            ...searchResults,
+            search: {
+                query: q,
+            },
+            autocomplete: transformedSuggestResults,
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+import { MetaRequestModel, MetaResponseModel } from '@searchspring/snapi-types';
+import { API } from '.';
+export declare class LegacyAPI extends API {
+    private getEndpoint;
+    postMeta(requestParameters: MetaRequestModel): Promise<MetaResponseModel>;
+    getMeta(queryParameters: MetaRequestModel): Promise<MetaResponseModel>;
+    getSearch(queryParameters: any): Promise<any>;
+    getAutocomplete(queryParameters: any): Promise<any>;
+    getFinder(queryParameters: any): Promise<any>;
+}
+//# sourceMappingURL=Legacy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Legacy.d.ts","sourceRoot":"","sources":["../../../../src/Client/apis/Legacy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEhF,OAAO,EAAE,GAAG,EAA0B,MAAM,GAAG,CAAC;AAEhD,qBAAa,SAAU,SAAQ,GAAG;YACnB,WAAW;IAiBnB,QAAQ,CAAC,iBAAiB,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAkBzE,OAAO,CAAC,eAAe,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAgBtE,SAAS,CAAC,eAAe,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAI7C,eAAe,CAAC,eAAe,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAInD,SAAS,CAAC,eAAe,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAGnD"}

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

@@ -0,0 +1,44 @@
+import { API } from '.';
+export class LegacyAPI extends API {
+    async getEndpoint(queryParameters, path = '/api/search/search.json') {
+        queryParameters.resultsFormat = 'native';
+        const headerParameters = {};
+        const legacyResponse = await this.request({
+            path,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, path + JSON.stringify(queryParameters));
+        return legacyResponse;
+    }
+    async postMeta(requestParameters) {
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        const response = await this.request({
+            path: '/api/meta/meta.json',
+            method: 'POST',
+            headers: headerParameters,
+            body: requestParameters,
+        }, '/api/meta/meta.json' + JSON.stringify(requestParameters));
+        return response;
+    }
+    async getMeta(queryParameters) {
+        const headerParameters = {};
+        const response = await this.request({
+            path: '/api/meta/meta.json',
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, '/api/meta/meta.json' + JSON.stringify(queryParameters));
+        return response;
+    }
+    async getSearch(queryParameters) {
+        return this.getEndpoint(queryParameters, '/api/search/search.json');
+    }
+    async getAutocomplete(queryParameters) {
+        return this.getEndpoint(queryParameters, '/api/search/autocomplete.json');
+    }
+    async getFinder(queryParameters) {
+        return this.getEndpoint(queryParameters, '/api/search/finder.json');
+    }
+}