@constructor-io/constructorio-client-javascript 2.31.0 → 2.32.0

package/lib/modules/quizzes.js

@@ -48,13 +48,13 @@ function createQuizUrl(quizId, parameters, options, path) {
     throw new Error('quizId is a required parameter of type string');
   }
 
-  if (path === 'finalize' && ((0, _typeof2["default"])(parameters.a) !== 'object' || !Array.isArray(parameters.a) || parameters.a.length === 0)) {
-    throw new Error('a is a required parameter of type array');
+  if (path === 'finalize' && ((0, _typeof2["default"])(parameters.answers) !== 'object' || !Array.isArray(parameters.answers) || parameters.answers.length === 0)) {
+    throw new Error('answers is a required parameter of type array');
   }
 
   if (parameters) {
     var section = parameters.section,
-        a = parameters.a,
+        answers = parameters.answers,
         versionId = parameters.versionId; // Pull section from parameters
 
     if (section) {
@@ -64,11 +64,11 @@ function createQuizUrl(quizId, parameters, options, path) {
 
     if (versionId) {
       queryParams.version_id = versionId;
-    } // Pull a (answers) from parameters and transform
+    } // Pull answers from parameters.answers and  transform
 
 
-    if (a) {
-      a.forEach(function (ans) {
+    if (answers) {
+      answers.forEach(function (ans) {
         answersParamString += "&".concat(qs.stringify({
           a: ans
         }, {
@@ -103,20 +103,20 @@ var Quizzes = /*#__PURE__*/function () {
   /**
    * Retrieve next question from API
    *
-   * @function getNextQuestion
+   * @function getQuizNextQuestion
    * @description Retrieve next question from Constructor.io API
    * @param {string} id - The identifier of the quiz
    * @param {string} [parameters] - Additional parameters to refine result set
    * @param {string} [parameters.section] - Product catalog section
-   * @param {array} [parameters.a] - An array of answers in the format [[1,2],[1]]
+   * @param {array} [parameters.answers] - An array of answers in the format [[1,2],[1]]
    * @param {string} [parameters.versionId] - Version identifier for the quiz
    * @param {object} [networkParameters] - Parameters relevant to the network request
    * @param {number} [networkParameters.timeout] - Request timeout (in milliseconds)
    * @returns {Promise}
    * @see https://docs.constructor.io/rest_api/quiz/using_quizzes/#answering-a-quiz
    * @example
-   * constructorio.quizzes.getNextQuestion('quizId', {
-   *    a: [[1,2],[1]],
+   * constructorio.quizzes.getQuizNextQuestion('quizId', {
+   *    answers: [[1,2],[1]],
    *    section: '123',
    *    versionId: '123'
    * });
@@ -124,8 +124,8 @@ var Quizzes = /*#__PURE__*/function () {
 
 
   (0, _createClass2["default"])(Quizzes, [{
-    key: "getNextQuestion",
-    value: function getNextQuestion(quizId, parameters) {
+    key: "getQuizNextQuestion",
+    value: function getQuizNextQuestion(quizId, parameters) {
       var _this = this;
 
       var networkParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
@@ -154,12 +154,12 @@ var Quizzes = /*#__PURE__*/function () {
         return helpers.throwHttpErrorFromResponse(new Error(), response);
       }).then(function (json) {
         if (json.version_id) {
-          _this.eventDispatcher.queue('quizzes.getNextQuestion.completed', json);
+          _this.eventDispatcher.queue('quizzes.getQuizNextQuestion.completed', json);
 
           return json;
         }
 
-        throw new Error('getNextQuestion response data is malformed');
+        throw new Error('getQuizNextQuestion response data is malformed');
       });
     }
     /**
@@ -170,7 +170,7 @@ var Quizzes = /*#__PURE__*/function () {
      * @param {string} id - The identifier of the quiz
      * @param {string} [parameters] - Additional parameters to refine result set
      * @param {string} [parameters.section] - Product catalog section
-     * @param {array} [parameters.a] - An array of answers in the format [[1,2],[1]]
+     * @param {array} [parameters.answers] - An array of answers in the format [[1,2],[1]]
      * @param {string} [parameters.versionId] - Specific version identifier for the quiz
      * @param {object} [networkParameters] - Parameters relevant to the network request
      * @param {number} [networkParameters.timeout] - Request timeout (in milliseconds)
@@ -178,7 +178,7 @@ var Quizzes = /*#__PURE__*/function () {
      * @see https://docs.constructor.io/rest_api/quiz/using_quizzes/#completing-the-quiz
      * @example
      * constructorio.quizzes.getQuizResults('quizId', {
-     *    a: [[1,2],[1]],
+     *    answers: [[1,2],[1]],
      *    section: '123',
      *    versionId: '123'
      * });

package/lib/modules/recommendations.js

@@ -149,8 +149,6 @@ var Recommendations = /*#__PURE__*/function () {
         helpers.applyNetworkTimeout(this.options, networkParameters, controller);
       }
 
-      parameters = parameters || {};
-
       try {
         requestUrl = createRecommendationsUrl(podId, parameters, this.options);
       } catch (e) {
@@ -170,6 +168,7 @@ var Recommendations = /*#__PURE__*/function () {
           if (json.result_id) {
             // Append `result_id` to each result item
             json.response.results.forEach(function (result) {
+              // eslint-disable-next-line no-param-reassign
               result.result_id = json.result_id;
             });
           }

package/lib/modules/search.js

@@ -242,6 +242,7 @@ var Search = /*#__PURE__*/function () {
         // Search results
         if (json.response && json.response.results) {
           if (json.result_id) {
+            // Append `result_id` to each result item
             json.response.results.forEach(function (result) {
               // eslint-disable-next-line no-param-reassign
               result.result_id = json.result_id;

package/lib/types/autocomplete.d.ts

@@ -0,0 +1,67 @@
+import {
+	ConstructorClientOptions,
+	RequestFeature,
+	RequestFeatureVariant,
+} from "./types";
+import EventDispatcher from "./event-dispatcher";
+
+/***************
+ *
+ * 	Autocomplete
+ *
+ ***************/
+export = Autocomplete;
+
+interface IAutocompleteParameters {
+	numResults: number;
+	filters: Record<string, any>;
+	resultsPerSection: Record<string, number>;
+	hiddenFields: string[];
+	variationsMap: Record<string, any>;
+}
+
+declare class Autocomplete {
+	constructor(options: ConstructorClientOptions);
+	options: ConstructorClientOptions;
+	eventDispatcher: EventDispatcher;
+
+	getAutocompleteResults(
+		query: string,
+		parameters?: IAutocompleteParameters,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Autocomplete.AutocompleteResponse>;
+}
+
+/***********
+ *
+ * 	Autocomplete results returned from server
+ *
+ ***********/
+declare namespace Autocomplete {
+	export interface AutocompleteResponse extends Record<string, any> {
+		request: Partial<Request>;
+		sections: Record<string, Section>;
+		result_id: string;
+	}
+}
+
+interface Request extends Record<string, any> {
+	num_results: number;
+	term: string;
+	query: string;
+	features: Partial<RequestFeature>;
+	feature_variants: Partial<RequestFeatureVariant>;
+	searchandized_items: Record<string, any>;
+}
+
+type Section = Partial<SectionItem>[]
+
+interface SectionItem extends Record<string, any> {
+	data: Record<string, any>;
+	is_slotted: boolean;
+	labels: Record<string, any>;
+	matched_terms: string[];
+	value: string;
+}

package/lib/types/browse.d.ts

@@ -0,0 +1,133 @@
+import { Collection, ConstructorClientOptions, ErrorData, Facet, Feature, Group, RequestFeature, RequestFeatureVariant, ResultSources, SortOption } from "./types";
+import EventDispatcher from "./event-dispatcher";
+
+/*********
+ *
+ * 	Browse
+ *
+ *********/
+export = Browse;
+
+interface IBrowseParameters {
+	page?: number;
+	offset?: number;
+	resultsPerPage?: number;
+	filters?: Record<string, any>;
+	sortBy?: string;
+	sortOrder?: string;
+	section?: string;
+	fmtOptions?: object;
+	preFilterExpression: Record<string, any>;
+	hiddenFields?: string[];
+	hiddenFacets?: string[];
+	variationsMap?: Record<string, any>;
+	qs?: Record<string, any>;
+}
+
+declare class Browse {
+	constructor(options: ConstructorClientOptions);
+	options: ConstructorClientOptions;
+	eventDispatcher: EventDispatcher;
+
+	getBrowseResults(
+		filterName: string,
+		filterValue: string,
+		parameters?: IBrowseParameters,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Browse.GetBrowseResultsResponse>;
+
+	getBrowseResultsForItemIds(
+		itemIds: string[],
+		parameters?: Omit<IBrowseParameters, "preFilterExpression" | "preFilterExpression">,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Browse.GetBrowseResultsForItemIdsResponse>;
+
+	getBrowseGroups(
+		parameters: Pick<IBrowseParameters, "filters" | "section" | "fmtOptions">,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Browse.GetBrowseGroupsResponse>;
+
+	getBrowseFacets(
+		parameters?: Pick<IBrowseParameters, "page" | "offset" | "section" | "fmtOptions"| "resultsPerPage">,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Browse.GetBrowseFacetsResponse>;
+
+	getBrowseFacetOptions(
+		facetName: string,
+		parameters?: Pick<IBrowseParameters, "section" | "fmtOptions">,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Browse.GetBrowseFacetOptionsResponse>;
+}
+
+/***********
+ *
+ * 	Browse results returned from server
+ *
+ ***********/
+declare namespace Browse {
+	export type GetBrowseResultsResponse = BrowseResponse<GetBrowseResultsResponseData>;
+	export type GetBrowseResultsForItemIdsResponse = BrowseResponse<GetBrowseResultsResponseData>;
+	export type GetBrowseGroupsResponse = BrowseResponse<Pick<GetBrowseResultsResponseData, "result_sources" | "groups" | "refined_content">>;
+	export type GetBrowseFacetsResponse = BrowseResponse<Pick<GetBrowseResultsResponseData, "facets" | "total_num_results">>;
+	export type GetBrowseFacetOptionsResponse = BrowseResponse<Pick<GetBrowseResultsResponseData, "facets">>;
+}
+
+interface BrowseResponse<ResponseType> extends Record<string, any> {
+	request?: Partial<Request>;
+	response?: Partial<ResponseType>;
+	result_id?: string;
+	ad_based?: boolean;
+
+}
+
+interface GetBrowseResultsResponseData extends Record<string, any> {
+	result_sources: Partial<ResultSources>;
+	facets: Partial<Facet>[];
+	groups: Partial<Group>[];
+	results: Partial<BrowseResultData>[];
+	sort_options: Partial<SortOption>[];
+	refined_content: Record<string, any>[];
+	total_num_results: number;
+	features: Partial<Feature>[];
+	collection: Partial<Collection>
+}
+
+interface BrowseResultData extends Record<string, any> {
+	matched_terms: string[];
+	data: {
+		id: string;
+		[key: string]: any;
+	};
+	value: string;
+	is_slotted: false;
+	labels: Record<string, any>;
+	variations: Record<string, any>[];
+}
+
+interface Request extends Record<string, any> {
+	browse_filter_name: string;
+	browse_filter_value: string;
+	filter_match_types: Record<string, any>,
+	filters: Record<string, any>,
+	fmt_options: Record<string, any>,
+	num_results_per_page: number;
+	page: number,
+	section: string,
+	sort_by: string,
+	sort_order: string,
+	term: string;
+	query: string;
+	features: Partial<RequestFeature>;
+	feature_variants: Partial<RequestFeatureVariant>;
+	searchandized_items: Record<string, any>;
+}

package/lib/types/constructorio.d.ts

@@ -0,0 +1,29 @@
+import Search from "./search";
+import Browse from "./browse";
+import Autocomplete from "./autocomplete";
+import Recommendations from "./recommendations";
+import Tracker from "./tracker";
+import { ConstructorClientOptions } from "./types";
+
+export = ConstructorIO;
+
+/*********************
+ *
+ * 	Constructor client
+ *
+ *********************/
+declare class ConstructorIO {
+	constructor(options: ConstructorClientOptions);
+	private options: ConstructorClientOptions;
+	search: Search;
+	browse: Browse;
+	autocomplete: Autocomplete;
+	recommendations: Recommendations;
+	tracker: Tracker;
+
+	setClientOptions(options: ConstructorClientOptions): void;
+}
+
+declare namespace ConstructorIO {
+	export { Tracker }
+}

package/lib/types/event-dispatcher.d.ts

@@ -0,0 +1,13 @@
+import { ConstructorClientOptions } from "./types";
+
+export = EventDispatcher;
+
+declare class EventDispatcher {
+	constructor(options: ConstructorClientOptions);
+	events: { name: string; data: Record<string, any> }[];
+	enabled: boolean;
+	waitForBeacon: boolean;
+	active: boolean;
+	queue(name: string, data: Record<string, any>): void;
+	dispatchEvents(): void;
+}

package/lib/types/recommendations.d.ts

@@ -0,0 +1,77 @@
+import { ConstructorClientOptions, ErrorData } from "./types";
+import EventDispatcher from "./event-dispatcher";
+
+/******************
+ *
+ * 	Recommendations
+ *
+ *****************/
+export = Recommendations;
+
+interface RecommendationsParameters {
+	itemIds?: string | string[];
+	numResults?: number;
+	section?: string;
+	term?: string;
+	filters?: Record<string, any>;
+	variationsMap?: Record<string, any>;
+}
+
+declare class Recommendations {
+	constructor(options: ConstructorClientOptions);
+	options: ConstructorClientOptions;
+	eventDispatcher: EventDispatcher;
+
+	getRecommendations(
+		podId: string,
+		parameters?: RecommendationsParameters,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Recommendations.RecommendationsResponse>;
+}
+
+/***********
+ *
+ * 	Recommendations results returned from server
+ *
+ ***********/
+declare namespace Recommendations {
+	export interface RecommendationsResponse extends Record<string, any> {
+		request: Partial<Request>;
+		response: Partial<Response>;
+		result_id: string;
+	}
+}
+
+interface Request extends Record<string, any> {
+	num_results: number;
+	item_id: string;
+	filters: {
+		group_id: string;
+		[key: string]: any;
+	};
+	pod_id: string;
+}
+
+interface Response extends Record<string, any> {
+	results: Partial<Result>;
+	total_num_results: number;
+	pod: {
+		id:string;
+		display_name: string;
+		[key: string]: any;
+	};
+}
+
+interface Result extends Record<string, any> {
+	matched_terms: string[];
+	data: Record<string, any>;
+	value: string;
+	is_slotted: boolean;
+	labels: Record<string, any>;
+	strategy: {
+		id: string;
+		[key: string]: any;
+	};
+}

package/lib/types/search.d.ts

@@ -0,0 +1,109 @@
+import {
+	ConstructorClientOptions,
+	ErrorData,
+	Facet,
+	Feature,
+	FmtOption,
+	Group,
+	RequestFeature,
+	RequestFeatureVariant,
+	ResultSources,
+	SortOption,
+} from "./types";
+import EventDispatcher from "./event-dispatcher";
+
+/***********
+ *
+ * 	SEARCH
+ *
+ ***********/
+
+export = Search;
+
+interface SearchParameters {
+	page?: number;
+	resultsPerPage?: number;
+	filters?: Record<string, any>;
+	sortBy?: string;
+	sortOrder?: string;
+	section?: string;
+	fmtOptions?: Record<string, any>;
+	hiddenFields?: string[];
+	hiddenFacets?: string[];
+	variationsMap?: Record<string, any>;
+}
+declare class Search {
+	constructor(options: ConstructorClientOptions);
+	options: ConstructorClientOptions;
+	eventDispatcher: EventDispatcher;
+	getSearchResults(
+		query: string,
+		parameters?: SearchParameters,
+		networkParameters?: {
+			timeout?: number;
+		}
+	): Promise<Search.SearchResponse>;
+}
+
+/***********
+ *
+ * 	search results returned from server
+ *
+ ***********/
+interface Response extends Record<string, any> {
+	result_sources: Partial<ResultSources>;
+	facets: Partial<Facet>[];
+	groups: Partial<Group>[];
+	results: Partial<Result>[];
+	sort_options: Partial<SortOption>[];
+	refined_content: Record<string, any>[];
+	total_num_results: number;
+	features: Partial<Feature>[];
+}
+
+interface Request extends Record<string, any> {
+	page: number;
+	num_results_per_page: number;
+	section: string;
+	blacklist_rules: boolean;
+	term: string;
+	fmt_options: Partial<FmtOption>;
+	sort_by: string;
+	sort_order: string;
+	features: Partial<RequestFeature>;
+	feature_variants: Partial<RequestFeatureVariant>;
+	searchandized_items: Record<string, any>;
+}
+
+interface Result extends Record<string, any> {
+	matched_terms: string[];
+	data: {
+		id: string;
+		[key: string]: any;
+	};
+	value: string;
+	is_slotted: false;
+	labels: Record<string, any>;
+	variations: Record<string, any>[];
+}
+
+declare namespace Search {
+	export interface SearchResponse {
+		request: Partial<Request>;
+		response: Partial<Response | Redirect>;
+		result_id: string;
+	}
+}
+
+interface Redirect extends Record<string, any> {
+	redirect: {
+		data: {
+			match_id: number;
+			rule_id: number;
+			url: string;
+			[key: string]: any;
+		};
+		matched_terms: string[];
+		matched_user_segments: string[];
+	}
+}

package/lib/types/tracker.d.ts

@@ -0,0 +1,162 @@
+import { ConstructorClientOptions } from "./types";
+import EventEmitter = require("events");
+import RequestQueue = require("../utils/request-queue");
+
+export = Tracker;
+
+/******************
+ *
+ * 	Tracker
+ *
+ *****************/
+declare class Tracker {
+    constructor(options: ConstructorClientOptions);
+    private options: ConstructorClientOptions;
+    private eventemitter: EventEmitter;
+    private requests: RequestQueue;
+  
+    trackSessionStart(networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackInputFocus(networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackItemDetailLoad(parameters: {
+        item_name: string;
+        item_id: string;
+        variation_id?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+   
+    trackAutocompleteSelect(term: string, parameters: {
+        original_query: string;
+        section: string;
+        tr?: string;
+        group_id?: string;
+        display_name?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackSearchSubmit(term: string, parameters: {
+        original_query: string;
+        group_id?: string;
+        display_name?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackSearchResultsLoaded(term: string, parameters: {
+        num_results: number;
+        item_ids?: string[];
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackSearchResultClick(term: string, parameters: {
+        item_name: string;
+        item_id: string;
+        variation_id?: string;
+        result_id?: string;
+        item_is_convertible?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackConversion(term?: string, parameters: {
+        item_id: string;
+        revenue?: number;
+        item_name?: string;
+        variation_id?: string;
+        type?: string;
+        is_custom_type?: boolean;
+        display_name?: string;
+        result_id?: string;
+        section?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackPurchase(parameters: {
+        items: object[];
+        revenue: number;
+        order_id?: string;
+        section?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackRecommendationView(parameters: {
+        url: string;
+        pod_id: string;
+        num_results_viewed: number;
+        items?: object[];
+        result_count?: number;
+        result_page?: number;
+        result_id?: string;
+        section?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackRecommendationClick(parameters: {
+        pod_id: string;
+        strategy_id: string;
+        item_id: string;
+        variation_id?: string;
+        section?: string;
+        result_id?: string;
+        result_count?: number;
+        result_page?: number;
+        result_position_on_page?: number;
+        num_results_per_page?: number;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+   
+    trackBrowseResultsLoaded(parameters: {
+        url: string;
+        filter_name: string;
+        filter_value: string;
+        section?: string;
+        result_count?: number;
+        result_page?: number;
+        result_id?: string;
+        selected_filters?: object;
+        sort_order?: string;
+        sort_by?: string;
+        items?: object[];
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackBrowseResultClick(parameters: {
+        filter_name: string;
+        filter_value: string;
+        item_id: string;
+        section?: string;
+        variation_id?: string;
+        result_id?: string;
+        result_count?: number;
+        result_page?: number;
+        result_position_on_page?: number;
+        num_results_per_page?: number;
+        selected_filters?: object;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    trackGenericResultClick(parameters: {
+        item_id: string;
+        item_name?: string;
+        variation_id?: string;
+        section?: string;
+    }, networkParameters?: {
+        timeout?: number;
+    }): (true | Error);
+    
+    on(messageType: string, callback: Function): (true | Error);
+}

package/lib/types/types.d.ts

@@ -0,0 +1,126 @@
+import EventDispatcher from './event-dispatcher';
+
+export interface ConstructorClientOptions {
+	apiKey: string;
+	version?: string;
+	serviceUrl?: string;
+	// session id is of type string in jsdocs but of type number in code usage
+	sessionId?: string;
+	clientId?: string;
+	userId?: string;
+	segments?: string[];
+	testCells?: Record<string, string>;
+	fetch?: any;
+	trackingSendDelay?: number;
+	sendTrackingEvents?: boolean;
+	sendReferrerWithTrackingEvents?: boolean;
+	eventDispatcher?: EventDispatcher;
+	beaconMode?: boolean;
+	networkParameters?: {
+		timeout: number;
+	};
+}
+
+export interface RequestFeature extends Record<string, any> {
+	query_items: boolean;
+	auto_generated_refined_query_rules: boolean;
+	manual_searchandizing: boolean;
+	personalization: boolean;
+	filter_items: boolean;
+}
+
+export interface RequestFeatureVariant extends Record<string, any> {
+	query_items: string;
+	auto_generated_refined_query_rules: string;
+	manual_searchandizing: string | null;
+	personalization: string;
+	filter_items: string;
+}
+
+export type ErrorData = {
+	message: string;
+	[key: string]: any;
+};
+
+export interface ResultSources extends Record<string, any> {
+	token_match: { count: number; [key: string]: any };
+	embeddings_match: { count: number; [key: string]: any };
+}
+
+export interface SortOption extends Record<string, any> {
+	sort_by: string;
+	display_name: string;
+	sort_order: string;
+	status: string;
+}
+
+export interface Feature extends Record<string, any> {
+	feature_name: string;
+	display_name: string;
+	enabled: boolean;
+	variant: {
+		name: string;
+		display_name: string;
+		[key: string]: any;
+	};
+}
+
+export interface FmtOption extends Record<string, any> {
+	groups_start: string;
+	groups_max_depth: number;
+}
+
+type Facet = RangeFacet | OptionFacet;
+
+export interface BaseFacet extends Record<string, any> {
+	data: Record<string, any>;
+	status: Record<string, any>;
+	display_name: string;
+	name: string;
+	hidden: boolean;
+}
+
+export interface RangeFacet extends BaseFacet, Record<string, any> {
+	max: number;
+	min: number;
+	type: "range";
+}
+
+export interface OptionFacet extends BaseFacet, Record<string, any> {
+	options: FacetOption[];
+	type: "multiple" | "single" | "hierarchical";
+}
+
+export interface FacetOption extends Record<string, any> {
+	count: number;
+	display_name: string;
+	value: string;
+	options?: FacetOption[];
+	range?: ["-inf" | number, "inf" | number];
+	status: string;
+}
+
+export interface Group extends BaseGroup, Record<string, any> {
+	count: number;
+	data: Record<string, any>;
+	parents: BaseGroup[];
+	children: Group[];
+}
+
+export interface Collection extends Record<string, any> {
+	collection_id: string,
+	display_name: string,
+	data: Record<string, any>
+}
+
+export interface BaseGroup extends Record<string, any> {
+	display_name: string;
+	group_id: string;
+}
+
+export interface FmtOptions extends Record<string, any> {
+	
+}
+
+export type Nullable<T> = T | null;
+

package/lib/utils/helpers.js

@@ -143,7 +143,7 @@ var utils = {
     var controller = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     var optionsTimeout = options && options.networkParameters && options.networkParameters.timeout;
     var networkParametersTimeout = networkParameters && networkParameters.timeout;
-    var timeout = optionsTimeout || networkParametersTimeout;
+    var timeout = networkParametersTimeout || optionsTimeout;
 
     if (typeof timeout === 'number' && controller) {
       setTimeout(function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructor-io/constructorio-client-javascript",
-  "version": "2.31.0",
+  "version": "2.32.0",
   "description": "Constructor.io JavaScript client",
   "main": "lib/constructorio.js",
   "scripts": {
@@ -9,9 +9,13 @@
     "check-lisc": "license-checker --production --onlyAllow 'Apache-2.0;BSD-3-Clause;MIT'",
     "lint": "eslint 'src/**/*.js' 'spec/**/*.js'",
     "test": "npm run compile && mkdir -p test && cp -rf lib/* test && mocha ./spec/*",
+    "test:parallel": "npm run compile && mkdir -p test && cp -rf lib/* test && mocha --parallel ./spec/*",
     "test:src": "mkdir -p test && cp -rf src/* test && mocha ./spec/*",
+    "test:src:parallel": "mkdir -p test && cp -rf src/* test && mocha --parallel ./spec/*",
     "test:bundled": "npm run bundle && BUNDLED=true PACKAGE_VERSION=$(echo $npm_package_version) mocha ./spec/*",
+    "test:bundled:parallel": "npm run bundle && BUNDLED=true PACKAGE_VERSION=$(echo $npm_package_version) mocha --parallel ./spec/*",
     "test:all": "npm run test && npm run test:bundled",
+    "test:all:parallel": "npm run test:parallel && npm run test:bundled:parallel",
     "precoverage": "rm -rf ./coverage && rm -rf ./.nyc_output",
     "coverage": "nyc --all --reporter=html npm run test:src",
     "postcoverage": "open coverage/index.html && rm -rf test",