@empathyco/x-components 3.0.0-alpha.7 → 3.0.0-alpha.70

package/js/store/utils/fetch-and-save-action.utils.js

@@ -0,0 +1,75 @@
+import { cancellablePromise, CancelSymbol } from '../../utils/cancellable-promise.js';
+
+/**
+ * Utility to create an action that requests and save some data asynchronously, with the
+ * option to cancel the request at any moment. This factory provides with the standard flow
+ * for requesting, cancelling, handling errors for a module, while also taking care of its status.
+ *
+ * @public
+ * @returns An action to fetch and save some data, and an action to cancel the last request.
+ */
+function createFetchAndSaveActions({ fetch, onSuccess, onError, onCancel }) {
+    let cancelPreviousRequest;
+    /**
+     * Called asynchronously after a response has been received.
+     *
+     * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the
+     * actions, provided by Vuex.
+     * @param response - The fetch response.
+     * @returns A Promise that resolves after handling the response.
+     */
+    function handleResponse(context, response) {
+        return Promise.resolve(onSuccess(context, response)).then(() => {
+            context.commit('setStatus', 'success');
+        });
+    }
+    /**
+     * Called immediately after a request has been cancelled.
+     *
+     * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the
+     * actions, provided by Vuex.
+     */
+    function handleCancel(context) {
+        cancelPreviousRequest = undefined;
+        context.commit('setStatus', 'success');
+        onCancel?.();
+    }
+    /**
+     * Called asynchronously whenever an error happens in the fetch and save flow.
+     *
+     * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the
+     * actions, provided by Vuex.
+     * @param error - The error information.
+     */
+    function handleError(context, error) {
+        if (error !== CancelSymbol) {
+            context.commit('setStatus', 'error');
+            onError?.(error);
+        }
+    }
+    // eslint-disable-next-line
+    /** @see FetchAndSaveActions.fetchAndSave */
+    function fetchAndSave(context, request) {
+        cancelPrevious();
+        context.commit('setStatus', 'loading');
+        const { promise, cancel } = cancellablePromise(fetch(context, request), () => {
+            handleCancel(context);
+        });
+        cancelPreviousRequest = cancel;
+        return promise
+            .then(response => handleResponse(context, response))
+            .catch(error => handleError(context, error));
+    }
+    // eslint-disable-next-line
+    /** @see FetchAndSaveActions.cancelPrevious */
+    function cancelPrevious() {
+        cancelPreviousRequest?.();
+    }
+    return {
+        fetchAndSave,
+        cancelPrevious
+    };
+}
+
+export { createFetchAndSaveActions };
+//# sourceMappingURL=fetch-and-save-action.utils.js.map

package/js/store/utils/fetch-and-save-action.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-and-save-action.utils.js","sources":["../../../../src/store/utils/fetch-and-save-action.utils.ts"],"sourcesContent":["import { cancellablePromise, CancelSymbol } from '../../utils/cancellable-promise';\nimport { XActionContext } from '../actions.types';\nimport { StatusMutations, StatusState } from './status-store.utils';\n\n/**\n * Utility to create an action that requests and save some data asynchronously, with the\n * option to cancel the request at any moment. This factory provides with the standard flow\n * for requesting, cancelling, handling errors for a module, while also taking care of its status.\n *\n * @public\n * @returns An action to fetch and save some data, and an action to cancel the last request.\n */\nexport function createFetchAndSaveActions<\n  // Using `object` type to ensure no actions/getters can be used.\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  Context extends XActionContext<StatusState, object, StatusMutations, object>,\n  Request,\n  Response\n>({\n  fetch,\n  onSuccess,\n  onError,\n  onCancel\n}: FetchAndSaveHooks<Context, Request, Response>): FetchAndSaveActions<Context, Request> {\n  let cancelPreviousRequest: undefined | (() => void);\n\n  /**\n   * Called asynchronously after a response has been received.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   * @param response - The fetch response.\n   * @returns A Promise that resolves after handling the response.\n   */\n  function handleResponse(context: Context, response: Response): Promise<void> {\n    return Promise.resolve(onSuccess(context, response)).then(() => {\n      context.commit('setStatus', 'success');\n    });\n  }\n\n  /**\n   * Called immediately after a request has been cancelled.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   */\n  function handleCancel(context: Context): void {\n    cancelPreviousRequest = undefined;\n    context.commit('setStatus', 'success');\n    onCancel?.();\n  }\n\n  /**\n   * Called asynchronously whenever an error happens in the fetch and save flow.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   * @param error - The error information.\n   */\n  function handleError(context: Context, error: unknown): void {\n    if (error !== CancelSymbol) {\n      context.commit('setStatus', 'error');\n      onError?.(error);\n    }\n  }\n\n  // eslint-disable-next-line\n  /** @see FetchAndSaveActions.fetchAndSave */\n  function fetchAndSave(context: Context, request: Request): Promise<void> {\n    cancelPrevious();\n    context.commit('setStatus', 'loading');\n    const { promise, cancel } = cancellablePromise(fetch(context, request), () => {\n      handleCancel(context);\n    });\n\n    cancelPreviousRequest = cancel;\n    return promise\n      .then(response => handleResponse(context, response))\n      .catch(error => handleError(context, error));\n  }\n\n  // eslint-disable-next-line\n  /** @see FetchAndSaveActions.cancelPrevious */\n  function cancelPrevious(): void {\n    cancelPreviousRequest?.();\n  }\n\n  return {\n    fetchAndSave,\n    cancelPrevious\n  };\n}\n\n/**\n * Options to use with the {@link createFetchAndSaveActions} factory.\n *\n * @public\n */\nexport interface FetchAndSaveHooks<\n  // Using `object` type to ensure no actions/getters can be used.\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  Context extends XActionContext<StatusState, object, StatusMutations, object>,\n  Request,\n  Response\n> {\n  /**\n   * Retrieves and returns asynchronously some data.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   * @param request - The request object used for fetching.\n   * @returns A Promise resolved with the response of the fetch request.\n   */\n  fetch(context: Context, request: Request): Promise<Response>;\n  /**\n   * Asynchronous callback executed when the {@link FetchAndSaveHooks.fetch} is\n   * performed successfully.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   * @param response - The data returned by {@link FetchAndSaveHooks.fetch}.\n   */\n  onSuccess(context: Context, response: Response): void;\n  /**\n   * Asynchronous callback executed when either the {@link FetchAndSaveHooks.fetch}\n   * or {@link FetchAndSaveHooks.onSuccess} methods fail.\n   *\n   * @param error - The error that triggered this callback.\n   */\n  onError?(error: unknown): void;\n  /**\n   * Synchronous callback executed when the request is cancelled. This can happen mainly for two\n   * reasons:\n   * - The {@link FetchAndSaveActions.cancelPrevious} action is dispatched.\n   * - A new {@link FetchAndSaveActions.fetchAndSave} is dispatched before the previous one was\n   * resolved.\n   */\n  onCancel?(): void;\n}\n\n/**\n * Actions returned from the {@link createFetchAndSaveActions}.\n *\n * @public\n */\nexport interface FetchAndSaveActions<\n  // Using `object` type to ensure no actions/getters can be used.\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  Context extends XActionContext<StatusState, object, StatusMutations, object>,\n  Request\n> {\n  /**\n   * Action that requests and saves the response.\n   *\n   * @param context - The {@link https://vuex.vuejs.org/guide/actions.html | context} of the\n   * actions, provided by Vuex.\n   * @returns A promise that resolves after saving the response.\n   */\n  fetchAndSave: (context: Context, request: Request) => void | Promise<void>;\n  /**\n   * Action that cancels the previous request call if it stills in progress.\n   */\n  cancelPrevious: () => void;\n}\n"],"names":[],"mappings":";;AAIA;;;;;;;;SAQgB,yBAAyB,CAMvC,EACA,KAAK,EACL,SAAS,EACT,OAAO,EACP,QAAQ,EACsC;IAC9C,IAAI,qBAA+C,CAAC;;;;;;;;;IAUpD,SAAS,cAAc,CAAC,OAAgB,EAAE,QAAkB;QAC1D,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;YACxD,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;SACxC,CAAC,CAAC;KACJ;;;;;;;IAQD,SAAS,YAAY,CAAC,OAAgB;QACpC,qBAAqB,GAAG,SAAS,CAAC;QAClC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QACvC,QAAQ,IAAI,CAAC;KACd;;;;;;;;IASD,SAAS,WAAW,CAAC,OAAgB,EAAE,KAAc;QACnD,IAAI,KAAK,KAAK,YAAY,EAAE;YAC1B,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;YACrC,OAAO,GAAG,KAAK,CAAC,CAAC;SAClB;KACF;;;IAID,SAAS,YAAY,CAAC,OAAgB,EAAE,OAAgB;QACtD,cAAc,EAAE,CAAC;QACjB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QACvC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE;YACtE,YAAY,CAAC,OAAO,CAAC,CAAC;SACvB,CAAC,CAAC;QAEH,qBAAqB,GAAG,MAAM,CAAC;QAC/B,OAAO,OAAO;aACX,IAAI,CAAC,QAAQ,IAAI,cAAc,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;aACnD,KAAK,CAAC,KAAK,IAAI,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;KAChD;;;IAID,SAAS,cAAc;QACrB,qBAAqB,IAAI,CAAC;KAC3B;IAED,OAAO;QACL,YAAY;QACZ,cAAc;KACf,CAAC;AACJ;;;;"}

package/js/store/utils/getters-proxy.utils.js

@@ -0,0 +1,100 @@
+import { reduce } from '../../utils/object.js';
+
+let cache = {};
+/**
+ * Creates or return a proxy object of the getters of the storeModule passed.
+ *
+ * @param getters - The Vuex Store Getters.
+ * @param moduleName - The name of the module.
+ * @param storeModule - The store module.
+ * @returns A {@link GettersTree} object with only the getters of the {@link XModule}.
+ *
+ * @internal
+ *
+ * @remarks This proxy will be used by the stateSelector, of the module. This is done to ensure that
+ * a Vuex stateSelector can only access the getters of the {@link XModule} where it is registered.
+ * This function task can be done with {@link getGettersProxy}, just without passing the
+ * storeModule. But in that case every time we register emitters in a module, it will loop over all
+ * the getters of all the store. This way, passing the moduleNeeded, it only loops over the getters
+ * of that module. It is a performance question to have this two different implementations.
+ *
+ */
+function getGettersProxyFromModule(getters, moduleName, storeModule) {
+    /* TODO: Review why TS is not able to exclude undefined types from the Getters cache */
+    const cachedGetter = cache[moduleName];
+    if (isCacheGetterDefined(cachedGetter)) {
+        return cachedGetter;
+    }
+    const modulePath = `x/${moduleName}/`;
+    const safeGetters = reduce(storeModule.getters, (safeGettersProxy, getterName) => defineGetterProxy(safeGettersProxy, getterName, `${modulePath}${getterName}`, getters), {});
+    cache[moduleName] = safeGetters;
+    return safeGetters;
+}
+/**
+ * Creates or return a proxy object of the getters of the module with the moduleName passed.
+ *
+ * @param getters - The Vuex Store Getters.
+ * @param moduleName - The name of the module.
+ * @returns A {@link GettersTree} object with only the getters of the {@link XModule}.
+ *
+ * @internal
+ *
+ * @remarks This proxy will be used wireCommit to pass the module state and getters, to a function
+ * that will return the payload to commit the mutation.
+ */
+function getGettersProxy(getters, moduleName) {
+    /* TODO: Review why TS is not able to exclude undefined types from the Getters cache */
+    const cachedGetter = cache[moduleName];
+    if (isCacheGetterDefined(cachedGetter)) {
+        return cachedGetter;
+    }
+    const modulePath = `x/${moduleName}/`;
+    const getterKeys = Object.keys(getters).filter(getterKey => getterKey.startsWith(modulePath));
+    const safeGetters = getterKeys.reduce((safeGettersProxy, fullPathGetterName) => {
+        const getterName = fullPathGetterName.replace(modulePath, '');
+        return defineGetterProxy(safeGettersProxy, getterName, fullPathGetterName, getters);
+    }, {});
+    cache[moduleName] = safeGetters;
+    return safeGetters;
+}
+/**
+ * Defines a JS getter in safeGettersProxy object that returns the Vuex getter value.
+ *
+ * @param safeGettersProxy - The object where the proxy will be defined.
+ * @param getterName - The name of the Getter without path. For example: 'trimQuery'.
+ * @param fullPathGetterName - The name of the getter to be accessed with the full path.
+ * For example: 'x/searchBox/trimmedQuery'.
+ * @param getters - The Vuex Store Getters.
+ * @returns The same safeGetterProxy with new get defined.
+ *
+ * @internal
+ */
+function defineGetterProxy(safeGettersProxy, getterName, fullPathGetterName, getters) {
+    return Object.defineProperty(safeGettersProxy, getterName, {
+        get() {
+            return getters[fullPathGetterName];
+        },
+        enumerable: true
+    });
+}
+/** Clean the cache (This is for testing purpose).
+ *
+ * @internal
+ * */
+function cleanGettersProxyCache() {
+    cache = {};
+}
+/**
+ * Checks if the getter cached is defined.
+ *
+ * @param cachedGetter - The getter cached.
+ * @returns If the getters is defined or not.
+ *
+ * @internal
+ */
+function isCacheGetterDefined(cachedGetter) {
+    return cachedGetter !== undefined;
+}
+
+export { cleanGettersProxyCache, getGettersProxy, getGettersProxyFromModule };
+//# sourceMappingURL=getters-proxy.utils.js.map

package/js/store/utils/getters-proxy.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getters-proxy.utils.js","sources":["../../../../src/store/utils/getters-proxy.utils.ts"],"sourcesContent":["import { Store } from 'vuex';\nimport { reduce } from '../../utils/object';\nimport { Dictionary } from '../../utils/types';\nimport { ExtractGetters, XModuleName } from '../../x-modules/x-modules.types';\nimport { AnyXStoreModule } from '../store.types';\n\ntype Getters = { [ModuleName in XModuleName]?: ExtractGetters<ModuleName> };\nlet cache: Getters = {};\n/**\n * Creates or return a proxy object of the getters of the storeModule passed.\n *\n * @param getters - The Vuex Store Getters.\n * @param moduleName - The name of the module.\n * @param storeModule - The store module.\n * @returns A {@link GettersTree} object with only the getters of the {@link XModule}.\n *\n * @internal\n *\n * @remarks This proxy will be used by the stateSelector, of the module. This is done to ensure that\n * a Vuex stateSelector can only access the getters of the {@link XModule} where it is registered.\n * This function task can be done with {@link getGettersProxy}, just without passing the\n * storeModule. But in that case every time we register emitters in a module, it will loop over all\n * the getters of all the store. This way, passing the moduleNeeded, it only loops over the getters\n * of that module. It is a performance question to have this two different implementations.\n *\n */\nexport function getGettersProxyFromModule<ModuleName extends XModuleName>(\n  getters: Pick<Store<any>, 'getters'>,\n  moduleName: ModuleName,\n  storeModule: AnyXStoreModule\n): ExtractGetters<ModuleName> {\n  /* TODO: Review why TS is not able to exclude undefined types from the Getters cache */\n  const cachedGetter = cache[moduleName];\n  if (isCacheGetterDefined<ModuleName>(cachedGetter)) {\n    return cachedGetter;\n  }\n  const modulePath = `x/${moduleName}/`;\n  const safeGetters = reduce(\n    storeModule.getters as Dictionary,\n    (safeGettersProxy, getterName) =>\n      defineGetterProxy(safeGettersProxy, getterName, `${modulePath}${getterName}`, getters),\n    {} as ExtractGetters<ModuleName>\n  );\n  cache[moduleName] = safeGetters as unknown as Getters[ModuleName];\n  return safeGetters;\n}\n\n/**\n * Creates or return a proxy object of the getters of the module with the moduleName passed.\n *\n * @param getters - The Vuex Store Getters.\n * @param moduleName - The name of the module.\n * @returns A {@link GettersTree} object with only the getters of the {@link XModule}.\n *\n * @internal\n *\n * @remarks This proxy will be used wireCommit to pass the module state and getters, to a function\n * that will return the payload to commit the mutation.\n */\nexport function getGettersProxy<ModuleName extends XModuleName>(\n  getters: Pick<Store<any>, 'getters'>,\n  moduleName: ModuleName\n): ExtractGetters<ModuleName> {\n  /* TODO: Review why TS is not able to exclude undefined types from the Getters cache */\n  const cachedGetter = cache[moduleName];\n  if (isCacheGetterDefined<ModuleName>(cachedGetter)) {\n    return cachedGetter;\n  }\n  const modulePath = `x/${moduleName}/`;\n  const getterKeys: string[] = Object.keys(getters).filter(getterKey =>\n    getterKey.startsWith(modulePath)\n  );\n  const safeGetters = getterKeys.reduce((safeGettersProxy, fullPathGetterName) => {\n    const getterName = fullPathGetterName.replace(modulePath, '');\n    return defineGetterProxy(safeGettersProxy, getterName, fullPathGetterName, getters);\n  }, {} as ExtractGetters<ModuleName>);\n  cache[moduleName] = safeGetters as unknown as Getters[ModuleName];\n  return safeGetters;\n}\n\n/**\n * Defines a JS getter in safeGettersProxy object that returns the Vuex getter value.\n *\n * @param safeGettersProxy - The object where the proxy will be defined.\n * @param getterName - The name of the Getter without path. For example: 'trimQuery'.\n * @param fullPathGetterName - The name of the getter to be accessed with the full path.\n * For example: 'x/searchBox/trimmedQuery'.\n * @param getters - The Vuex Store Getters.\n * @returns The same safeGetterProxy with new get defined.\n *\n * @internal\n */\nfunction defineGetterProxy<ModuleName extends XModuleName>(\n  safeGettersProxy: ExtractGetters<ModuleName>,\n  getterName: string,\n  fullPathGetterName: string,\n  getters: Dictionary\n): ExtractGetters<ModuleName> {\n  return Object.defineProperty(safeGettersProxy, getterName, {\n    get() {\n      return getters[fullPathGetterName];\n    },\n    enumerable: true\n  });\n}\n\n/** Clean the cache (This is for testing purpose).\n *\n * @internal\n * */\nexport function cleanGettersProxyCache(): void {\n  cache = {};\n}\n\n/**\n * Checks if the getter cached is defined.\n *\n * @param cachedGetter - The getter cached.\n * @returns If the getters is defined or not.\n *\n * @internal\n */\nfunction isCacheGetterDefined<ModuleName extends XModuleName>(\n  cachedGetter: ExtractGetters<ModuleName> | undefined | unknown\n): cachedGetter is ExtractGetters<ModuleName> {\n  return cachedGetter !== undefined;\n}\n"],"names":[],"mappings":";;AAOA,IAAI,KAAK,GAAY,EAAE,CAAC;AACxB;;;;;;;;;;;;;;;;;;SAkBgB,yBAAyB,CACvC,OAAoC,EACpC,UAAsB,EACtB,WAA4B;;IAG5B,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;IACvC,IAAI,oBAAoB,CAAa,YAAY,CAAC,EAAE;QAClD,OAAO,YAAY,CAAC;KACrB;IACD,MAAM,UAAU,GAAG,KAAK,UAAU,GAAG,CAAC;IACtC,MAAM,WAAW,GAAG,MAAM,CACxB,WAAW,CAAC,OAAqB,EACjC,CAAC,gBAAgB,EAAE,UAAU,KAC3B,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,EAAE,GAAG,UAAU,GAAG,UAAU,EAAE,EAAE,OAAO,CAAC,EACxF,EAAgC,CACjC,CAAC;IACF,KAAK,CAAC,UAAU,CAAC,GAAG,WAA6C,CAAC;IAClE,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;SAYgB,eAAe,CAC7B,OAAoC,EACpC,UAAsB;;IAGtB,MAAM,YAAY,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC;IACvC,IAAI,oBAAoB,CAAa,YAAY,CAAC,EAAE;QAClD,OAAO,YAAY,CAAC;KACrB;IACD,MAAM,UAAU,GAAG,KAAK,UAAU,GAAG,CAAC;IACtC,MAAM,UAAU,GAAa,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,SAAS,IAChE,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,CACjC,CAAC;IACF,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,gBAAgB,EAAE,kBAAkB;QACzE,MAAM,UAAU,GAAG,kBAAkB,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAC9D,OAAO,iBAAiB,CAAC,gBAAgB,EAAE,UAAU,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;KACrF,EAAE,EAAgC,CAAC,CAAC;IACrC,KAAK,CAAC,UAAU,CAAC,GAAG,WAA6C,CAAC;IAClE,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;;;;;AAYA,SAAS,iBAAiB,CACxB,gBAA4C,EAC5C,UAAkB,EAClB,kBAA0B,EAC1B,OAAmB;IAEnB,OAAO,MAAM,CAAC,cAAc,CAAC,gBAAgB,EAAE,UAAU,EAAE;QACzD,GAAG;YACD,OAAO,OAAO,CAAC,kBAAkB,CAAC,CAAC;SACpC;QACD,UAAU,EAAE,IAAI;KACjB,CAAC,CAAC;AACL,CAAC;AAED;;;;SAIgB,sBAAsB;IACpC,KAAK,GAAG,EAAE,CAAC;AACb,CAAC;AAED;;;;;;;;AAQA,SAAS,oBAAoB,CAC3B,YAA8D;IAE9D,OAAO,YAAY,KAAK,SAAS,CAAC;AACpC;;;;"}

package/js/store/utils/query.utils.js

@@ -0,0 +1,37 @@
+/**
+ * Sets the query of the module.
+ *
+ * @param state - State of the module.
+ * @param query - The new query to set.
+ * @public
+ */
+function setQuery(state, query) {
+    state.query = query;
+}
+/**
+ * Creates a getter that combines the current selected related tags and the query of the module.
+ *
+ * @param options - Options on how the getter should behave.
+ * @returns A getter that combines the selected related tags with the query.
+ * @public
+ */
+function createRelatedTagsQueryGetter({ getRelatedTags }) {
+    return function relatedTagsQuery(state, getters) {
+        const query = state.query.trim();
+        return query ? getRelatedTags(state, getters).reduce(concatRelatedTag, query).trim() : '';
+    };
+}
+/**
+ * Joins a query and a related tag respecting the tag position.
+ *
+ * @param partialQuery - The query to concatenate the related tag with.
+ * @param relatedTag - The related tag to concatenate.
+ * @returns The query and the related tag joined.
+ * @internal
+ */
+function concatRelatedTag(partialQuery, { tag, query: relatedTagQuery }) {
+    return relatedTagQuery.startsWith(tag) ? `${tag} ${partialQuery}` : `${partialQuery} ${tag}`;
+}
+
+export { createRelatedTagsQueryGetter, setQuery };
+//# sourceMappingURL=query.utils.js.map

package/js/store/utils/query.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.utils.js","sources":["../../../../src/store/utils/query.utils.ts"],"sourcesContent":["import { RelatedTag } from '@empathyco/x-types';\n\n/**\n * Query state type, containing a property to hold the current query of the module.\n *\n * @public\n */\nexport interface QueryState {\n  /** The query of the module. Different modules may have queries that differ in value\n   * or time. */\n  query: string;\n}\n\n/**\n * The {@link QueryState} mutations.\n *\n * @public\n */\nexport interface QueryMutations {\n  /**\n   * Sets the query.\n   *\n   * @param query - The new query.\n   */\n  setQuery(query: string): void;\n}\n\n/**\n * Options to create a getter that combines the query with the selected related tags.\n *\n * @public\n */\nexport interface CreateRelatedTagsQueryGetterOptions<State, Getters> {\n  /**\n   * Retrieves the selected related tags of the module.\n   *\n   * @param state - The state of the module.\n   * @param getters - The getters of the module.\n   * @returns The list of selected related tags.\n   */\n  getRelatedTags: (state: State, getters: Getters) => RelatedTag[];\n}\n\n/**\n * Sets the query of the module.\n *\n * @param state - State of the module.\n * @param query - The new query to set.\n * @public\n */\nexport function setQuery(state: QueryState, query: string): void {\n  state.query = query;\n}\n\n/**\n * Creates a getter that combines the current selected related tags and the query of the module.\n *\n * @param options - Options on how the getter should behave.\n * @returns A getter that combines the selected related tags with the query.\n * @public\n */\nexport function createRelatedTagsQueryGetter<State extends QueryState, Getters>({\n  getRelatedTags\n}: CreateRelatedTagsQueryGetterOptions<State, Getters>): (\n  state: State,\n  getters: Getters\n) => string {\n  return function relatedTagsQuery(state, getters) {\n    const query = state.query.trim();\n    return query ? getRelatedTags(state, getters).reduce(concatRelatedTag, query).trim() : '';\n  };\n}\n\n/**\n * Joins a query and a related tag respecting the tag position.\n *\n * @param partialQuery - The query to concatenate the related tag with.\n * @param relatedTag - The related tag to concatenate.\n * @returns The query and the related tag joined.\n * @internal\n */\nfunction concatRelatedTag(\n  partialQuery: string,\n  { tag, query: relatedTagQuery }: RelatedTag\n): string {\n  return relatedTagQuery.startsWith(tag) ? `${tag} ${partialQuery}` : `${partialQuery} ${tag}`;\n}\n"],"names":[],"mappings":"AA2CA;;;;;;;SAOgB,QAAQ,CAAC,KAAiB,EAAE,KAAa;IACvD,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC;AACtB,CAAC;AAED;;;;;;;SAOgB,4BAA4B,CAAoC,EAC9E,cAAc,EACsC;IAIpD,OAAO,SAAS,gBAAgB,CAAC,KAAK,EAAE,OAAO;QAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACjC,OAAO,KAAK,GAAG,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC;KAC3F,CAAC;AACJ,CAAC;AAED;;;;;;;;AAQA,SAAS,gBAAgB,CACvB,YAAoB,EACpB,EAAE,GAAG,EAAE,KAAK,EAAE,eAAe,EAAc;IAE3C,OAAO,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,IAAI,YAAY,EAAE,GAAG,GAAG,YAAY,IAAI,GAAG,EAAE,CAAC;AAC/F;;;;"}

package/js/store/utils/status-store.utils.js

@@ -0,0 +1,13 @@
+/**
+ * Sets the request status. Can be used as a mutation.
+ *
+ * @param state - The {@link https://vuex.vuejs.org/guide/state.html | state} provided by Vuex.
+ * @param status - The new request status.
+ * @public
+ */
+function setStatus(state, status) {
+    state.status = status;
+}
+
+export { setStatus };
+//# sourceMappingURL=status-store.utils.js.map

package/js/store/utils/status-store.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-store.utils.js","sources":["../../../../src/store/utils/status-store.utils.ts"],"sourcesContent":["/**\n * Status state type, containing a property to hold the status property.\n *\n * @public\n */\nexport interface StatusState {\n  /** The request status. Useful for changing the displayed component depending on whether the\n   * request has succeeded, has not been fulfilled or has failed. */\n  status: RequestStatus;\n}\n\n/**\n * Status mutations, containing a method to change the current status.\n *\n * @public\n */\nexport interface StatusMutations {\n  /**\n   * Sets the request status.\n   *\n   * @param status - The new request status.\n   */\n  setStatus(status: RequestStatus): void;\n}\n\n/**\n * The possible status of a request:\n * - Success: The request has resolved successfully.\n * - Loading: The request is in process, waiting for a response.\n * - Error: The request has failed.\n *\n * @public\n */\nexport type RequestStatus = 'success' | 'loading' | 'error' | 'initial';\n\n/**\n * Sets the request status. Can be used as a mutation.\n *\n * @param state - The {@link https://vuex.vuejs.org/guide/state.html | state} provided by Vuex.\n * @param status - The new request status.\n * @public\n */\nexport function setStatus(state: StatusState, status: RequestStatus): void {\n  state.status = status;\n}\n"],"names":[],"mappings":"AAmCA;;;;;;;SAOgB,SAAS,CAAC,KAAkB,EAAE,MAAqB;IACjE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;AACxB;;;;"}

package/js/store/utils/store-emitters.utils.js

@@ -0,0 +1,14 @@
+/**
+ * Helper function for creating type-safe {@link StoreEmitters}.
+ *
+ * @param storeModule - The store module that the emitters will be associated to.
+ * @param emitters - The {@link StoreEmitters} to create.
+ * @returns A type-safe function for storeEmitters.
+ * @public
+ */
+function createStoreEmitters(storeModule, emitters) {
+    return emitters;
+}
+
+export { createStoreEmitters };
+//# sourceMappingURL=store-emitters.utils.js.map

package/js/store/utils/store-emitters.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-emitters.utils.js","sources":["../../../../src/store/utils/store-emitters.utils.ts"],"sourcesContent":["import { WatchOptions } from 'vue';\nimport { Dictionary, Returns } from '../../utils/types';\nimport { XEvent, XEventPayload } from '../../wiring/events.types';\nimport { AnyXStoreModule } from '../store.types';\n\n/**\n * Selects a part of the store state or getters (AKA \"getter\" inside\n * {@link https://vuex.vuejs.org/ | Vuex} watchers).\n *\n * @param ReturnType - The type of the state or getters property selected.\n * @param State - The type of the state of the {@link XModule} where this selector is used.\n * @param Getters - The type of the getters of the {@link XModule} where this selector is used.\n * @public\n */\nexport type SimpleStateSelector<\n  ReturnType,\n  State extends Dictionary,\n  Getters extends Dictionary\n> = (state: State, getters: Getters) => ReturnType;\n\n/**\n * Composition type of {@link SimpleStateSelector} which allows to indicate if the state selector\n * should be executed in first instance (first assignment of values). Selector is the\n * {@link SimpleStateSelector} and immediate flags if the selector should be executed when it is\n * initialized for first time.\n *\n * @param ReturnType - The type of the state or getters property selected.\n * @param State - The type of the state of the {@link XModule} where this selector is used.\n * @param Getters - The type of the getters of the {@link XModule} where this selector is used.\n * @public\n */\nexport interface StateSelector<ReturnType, State extends Dictionary, Getters extends Dictionary>\n  extends WatchOptions {\n  selector: SimpleStateSelector<ReturnType, State, Getters>;\n  /**\n   * Checks if the value of the selector has changed.\n   *\n   * @remarks\n   * This function exist because Vue will not stop reactivity propagation if the observed variable\n   * is an `object`, an `Array`, or the `deep` mode has been enabled.\n   *\n   * @param newValue - The new value.\n   * @param oldValue - The old value.\n   * @returns True if the value has really changed.\n   */\n  filter?(newValue: ReturnType, oldValue: ReturnType): boolean;\n}\n\n/**\n * Dictionary where the key is a {@link XEvent}, and the value is {@link SimpleStateSelector} or\n * {@link StateSelector}. This {@link SimpleStateSelector} or {@link StateSelector} can only\n * access the state and getters from the {@link XStoreModule} passed as param type. This\n * dictionary is used to emits a {@link XEvent} when the part of the store selected by\n * {@link SimpleStateSelector} changes.\n *\n * @param StoreModule - The store module that these store emitters will be able to access.\n * @public\n */\nexport type StoreEmitters<StoreModule extends AnyXStoreModule> = {\n  [Event in XEvent]?:\n    | SimpleStateSelector<\n        XEventPayload<Event>,\n        ReturnType<StoreModule['state']>,\n        Returns<StoreModule['getters']>\n      >\n    | StateSelector<\n        XEventPayload<Event>,\n        ReturnType<StoreModule['state']>,\n        Returns<StoreModule['getters']>\n      >;\n};\n/**\n * Alias for any simple state selector.\n *\n * @public\n */\nexport type AnySimpleStateSelector = SimpleStateSelector<any, any, any>;\n/**\n * Alias for any state selector.\n *\n * @public\n */\nexport type AnyStateSelector = StateSelector<any, any, any>;\n/**\n * Alias for any store emitters.\n *\n * @public\n */\nexport type AnyStoreEmitters = StoreEmitters<AnyXStoreModule>;\n\n/**\n * Helper function for creating type-safe {@link StoreEmitters}.\n *\n * @param storeModule - The store module that the emitters will be associated to.\n * @param emitters - The {@link StoreEmitters} to create.\n * @returns A type-safe function for storeEmitters.\n * @public\n */\nexport function createStoreEmitters<\n  Module extends AnyXStoreModule,\n  Emitters extends StoreEmitters<Module>\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental\n>(storeModule: Module, emitters: Emitters): Emitters {\n  return emitters;\n}\n"],"names":[],"mappings":"AA0FA;;;;;;;;SAQgB,mBAAmB,CAIjC,WAAmB,EAAE,QAAkB;IACvC,OAAO,QAAQ,CAAC;AAClB;;;;"}

package/js/store/x.module.js

@@ -4,23 +4,25 @@
  *
  * @internal
  */
-var RootXStoreModule = {
-    state: function () { return ({
+const RootXStoreModule = {
+    state: () => ({
         device: null,
         empathize: null,
+        extraParams: null,
+        facets: null,
+        historyQueries: null,
+        identifierResults: null,
         nextQueries: null,
         popularSearches: null,
-        searchBox: null,
         querySuggestions: null,
-        historyQueries: null,
         recommendations: null,
         relatedTags: null,
-        noSuggestions: null,
-        identifierResults: null,
+        scroll: null,
         search: null,
-        facets: null,
-        tagging: null
-    }); },
+        searchBox: null,
+        tagging: null,
+        url: null
+    }),
     namespaced: true
 };
 

package/js/store/x.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"x.module.js","sources":["../../../src/store/x.module.ts"],"sourcesContent":["import { Module } from 'vuex';\nimport { RootXStoreState } from './store.types';\n\n/**\n * The type of the x module state has a property for each other sub-module assigned to `null`,\n * so we can avoid re-executing getters every time\n * the `store.registerModule` method is called.\n *\n * @internal\n */\nexport type XModuleState = { [Key in keyof RootXStoreState['x']]: null };\n\n/**\n * The main module of the X Store. All of the other {@link XModule | XModules} will be\n * registered as a sub-module of this one.\n *\n * @internal\n */\nexport const RootXStoreModule: Module<XModuleState, any> = {\n  state: () => ({\n    device: null,\n    empathize: null,\n    nextQueries: null,\n    popularSearches: null,\n    searchBox: null,\n    querySuggestions: null,\n    historyQueries: null,\n    recommendations: null,\n    relatedTags: null,\n    noSuggestions: null,\n    identifierResults: null,\n    search: null,\n    facets: null,\n    tagging: null\n  }),\n  namespaced: true\n};\n"],"names":[],"mappings":"AAYA;;;;;;IAMa,gBAAgB,GAA8B;IACzD,KAAK,EAAE,cAAM,QAAC;QACZ,MAAM,EAAE,IAAI;QACZ,SAAS,EAAE,IAAI;QACf,WAAW,EAAE,IAAI;QACjB,eAAe,EAAE,IAAI;QACrB,SAAS,EAAE,IAAI;QACf,gBAAgB,EAAE,IAAI;QACtB,cAAc,EAAE,IAAI;QACpB,eAAe,EAAE,IAAI;QACrB,WAAW,EAAE,IAAI;QACjB,aAAa,EAAE,IAAI;QACnB,iBAAiB,EAAE,IAAI;QACvB,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,IAAI;QACZ,OAAO,EAAE,IAAI;KACd,IAAC;IACF,UAAU,EAAE,IAAI;;;;;"}
+{"version":3,"file":"x.module.js","sources":["../../../src/store/x.module.ts"],"sourcesContent":["import { Module } from 'vuex';\nimport { RootXStoreState } from './store.types';\n\n/**\n * The type of the x module state has a property for each other sub-module assigned to `null`,\n * so we can avoid re-executing getters every time\n * the `store.registerModule` method is called.\n *\n * @internal\n */\nexport type XModuleState = { [Key in keyof RootXStoreState['x']]: null };\n\n/**\n * The main module of the X Store. All of the other {@link XModule | XModules} will be\n * registered as a sub-module of this one.\n *\n * @internal\n */\nexport const RootXStoreModule: Module<XModuleState, any> = {\n  state: () => ({\n    device: null,\n    empathize: null,\n    extraParams: null,\n    facets: null,\n    historyQueries: null,\n    identifierResults: null,\n    nextQueries: null,\n    popularSearches: null,\n    querySuggestions: null,\n    recommendations: null,\n    relatedTags: null,\n    scroll: null,\n    search: null,\n    searchBox: null,\n    tagging: null,\n    url: null\n  }),\n  namespaced: true\n};\n"],"names":[],"mappings":"AAYA;;;;;;MAMa,gBAAgB,GAA8B;IACzD,KAAK,EAAE,OAAO;QACZ,MAAM,EAAE,IAAI;QACZ,SAAS,EAAE,IAAI;QACf,WAAW,EAAE,IAAI;QACjB,MAAM,EAAE,IAAI;QACZ,cAAc,EAAE,IAAI;QACpB,iBAAiB,EAAE,IAAI;QACvB,WAAW,EAAE,IAAI;QACjB,eAAe,EAAE,IAAI;QACrB,gBAAgB,EAAE,IAAI;QACtB,eAAe,EAAE,IAAI;QACrB,WAAW,EAAE,IAAI;QACjB,MAAM,EAAE,IAAI;QACZ,MAAM,EAAE,IAAI;QACZ,SAAS,EAAE,IAAI;QACf,OAAO,EAAE,IAAI;QACb,GAAG,EAAE,IAAI;KACV,CAAC;IACF,UAAU,EAAE,IAAI;;;;;"}

package/js/utils/array.js

@@ -25,7 +25,7 @@ function isArrayEmpty(array) {
  * @public
  */
 function arrayToObject(array, key) {
-    return array.reduce(function (accumulator, current) {
+    return array.reduce((accumulator, current) => {
         if (key) {
             accumulator[current[key]] = current;
         }
@@ -46,8 +46,8 @@ function arrayToObject(array, key) {
  * @public
  */
 function groupItemsBy(array, groupBy) {
-    return array.reduce(function (accumulator, current) {
-        var keyValue = groupBy(current);
+    return array.reduce((accumulator, current, index) => {
+        const keyValue = groupBy(current, index);
         if (!accumulator[keyValue]) {
             accumulator[keyValue] = [];
         }
@@ -56,13 +56,13 @@ function groupItemsBy(array, groupBy) {
     }, {});
 }
 /**
- * Filters an array with all elements that pass the test implemented by the provided filter
- * function. It also does it recursively if the property accessed, whose name is the parameter
- * childrenKey, to the current iteration in an array.
+ * Filters an array with all elements that pass the test implemented by the given filter
+ * function. If an item has another list of items in the `childrenKey` property it recursively
+ * filters that new list, adding it to the returned one.
  *
  * @param array - Array to be filtered.
- * @param filter - Predicate function to test each element of the array. It should return true
- * to keep the element; or false otherwise.
+ * @param condition - Predicate function to test each element of the array. It should return `true`
+ * to keep the element; or `false` otherwise.
  * @param childrenKey - Property name within the array used to perform a recursive call.
  *
  * @example
@@ -130,70 +130,57 @@ function groupItemsBy(array, groupBy) {
  *    ]
  * ```
  *
- * @returns A new array with the elements that pass the test, or an empty array if no one
+ * @returns A new array with the elements that pass the condition, or an empty array if no one
  * pass the test.
  *
  * @public
  */
-function deepFilter(array, filter, childrenKey) {
-    var filterArray = function (currentArray, initialArray) {
-        if (initialArray === void 0) { initialArray = []; }
-        return currentArray.reduce(function (result, currentItem) {
-            if (filter(currentItem)) {
-                result.push(currentItem);
-                filterArray(currentItem[childrenKey], result);
-            }
-            return result;
-        }, initialArray);
-    };
-    return filterArray(array);
+function deepFilter(array, condition, childrenKey) {
+    return array.reduce(function filter(filteredArray, item) {
+        if (condition(item)) {
+            filteredArray.push(item);
+            item[childrenKey]?.reduce(filter, filteredArray);
+        }
+        return filteredArray;
+    }, []);
 }
 /**
- * Flat an ArrayType[] recursively using the childrenKey passed as parameter to access to his nested
- * child which is also ArrayType[].
+ * Flat an `Item[]` deeply using the given `childrenKey` to access to his children.
  *
- * @param array - ArrayType[] which each ArrayType has a property childrenKey which value is also
- * an ArrayType[].
- * @param childrenKey - Key used to access to each ArrayType[childrenKey] value which is also
- * an ArrayType[].
+ * @param array - The list of items to flat. Each item may have another list of items of
+ * the same type to flat.
+ * @param childrenKey - Property name where each of the items of the given array may have another
+ * list of items to be flattened.
  *
- * @returns ArrayType[] with all the nested ArrayType, including the nested ones, at the same depth
- * level.
+ * @returns A flat list with all the found items.
  *
  * @public
  */
 function deepFlat(array, childrenKey) {
-    /**
-     * Flats an array recursively. In each iteration:
-     * - If the currentItem is an array, flatArray is used to reduce it. So, the order of the
-     * flatArray arguments defined is important. This happens when the function is called passing an
-     * array as the second parameter.
-     * - If not, the item is pushed to the resultantArray.
-     * - Finally, flatArray function is called again with the currentItem children and the process
-     * starts again.
-     *
-     * It's the main function of the parent. See the description above
-     * for further information.
-     *
-     * @param resultantArray - Flattened array.
-     * @param currentItem - ArrayType object.
-     *
-     * @returns Flattened ArrayType[].
-     *
-     * @internal
-     */
-    function flatArray(resultantArray, currentItem) {
-        if (!currentItem) {
-            return resultantArray;
-        }
-        if (Array.isArray(currentItem)) {
-            return currentItem.reduce(flatArray, resultantArray);
-        }
-        resultantArray.push(currentItem);
-        return flatArray(resultantArray, currentItem[childrenKey]);
-    }
-    return flatArray([], array);
+    return array.reduce(function flat(flattenedArray, item) {
+        flattenedArray.push(item);
+        item[childrenKey]?.reduce(flat, flattenedArray);
+        return flattenedArray;
+    }, []);
+}
+/**
+ * Creates an Emitter filter function to compare two arrays and filter those that are equal.
+ *
+ * @param comparator - String with the name of the field of the arrays items to compare, or function
+ * to compare items directly.
+ * @returns The comparator function that receives two arrays to compare them.
+ *
+ * @internal
+ */
+function createEmitterArrayFilter(comparator) {
+    const comparatorFn = typeof comparator === 'function'
+        ? comparator
+        : (newItem, oldItem) => newItem[comparator] === oldItem[comparator];
+    return function (newCollection, oldCollection) {
+        return (newCollection.length !== oldCollection.length ||
+            newCollection.some(newItem => !oldCollection.find(oldItem => comparatorFn(newItem, oldItem))));
+    };
 }
 
-export { arrayToObject, deepFilter, deepFlat, groupItemsBy, isArrayEmpty };
+export { arrayToObject, createEmitterArrayFilter, deepFilter, deepFlat, groupItemsBy, isArrayEmpty };
 //# sourceMappingURL=array.js.map

package/js/utils/array.js.map

@@ -1 +1 @@
-{"version":3,"file":"array.js","sources":["../../../src/utils/array.ts"],"sourcesContent":["import { PropsWithType } from './types';\n\n/**\n * Returns if the given array is `null`, `undefined`, or has no elements.\n *\n * @param array - The array to check if it is empty.\n * @returns `true` if the array is `null`, `undefined`, or has no elements. `false` otherwise.\n * @public\n */\nexport function isArrayEmpty(array: unknown[] | undefined | null): array is undefined | null | [] {\n  return array == null || array.length === 0;\n}\n\n/**\n * Reduce an array of strings to an object which properties names are the value of each string,\n * and the value under that property are also the string.\n *\n * @param array - Array of strings that will be used to create the object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the\n * array.\n *\n * @example Converting an array to an object:\n *         arrayToObject(['a', 'b', 'c']) === \\{a: 'a', b: 'b', c: 'c'\\}\n *\n * @public\n */\nexport function arrayToObject(array: string[]): Record<string, string>;\n/**\n * Reduce an array of objects to an object which properties names are the value of each object[key],\n * and the value under that property are each object. 'key' is the the parameter passed to this\n * function.\n *\n * @param array - Array of objects that contains objects which have object[key] string as a property\n * value.\n * @param key - Key used to access to each object[key] value, used for each property name in the new\n * object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the array.\n *\n * @public\n */\nexport function arrayToObject<ArrayType, KeyType extends string | number>(\n  array: ArrayType[],\n  key: PropsWithType<ArrayType, KeyType>\n): Record<string, ArrayType>;\n/**\n * Reduce an array to an object. The type of the object returned depends on the type of the params.\n * If the 'key' is passed then the function returns an object which properties names are the value\n * of each object[key] and the value under that property are each object.\n * If the 'key' is not passed then the function returns an object which properties names are each\n * array item, and the value is also the array item.\n *\n * @param array - Array from which to create an object.\n * @param key - Key used to access to each object[key] value, used for each property name in the\n * new object.\n *\n * @returns New object which properties object[key] contains each item in the array and the key is\n * either the item of the array or a property of each item designated by 'key' param.\n *\n * @public\n */\nexport function arrayToObject<ArrayType, KeyType extends string | number>(\n  array: ArrayType[],\n  key?: PropsWithType<ArrayType, KeyType>\n): Record<string, ArrayType> {\n  return array.reduce<Record<string, ArrayType>>((accumulator, current) => {\n    if (key) {\n      accumulator[current[key] as unknown as string] = current;\n    } else if (typeof current === 'string') {\n      accumulator[current] = current;\n    }\n    return accumulator;\n  }, {});\n}\n\n/**\n * Groups the array items based on the provided `groupBy` function.\n *\n * @param array - The array to iterate, grouping its items in different arrays based on the\n * `groupBy` function.\n * @param groupBy - A function to determine the group name of a single item.\n * @returns The items grouped in a dictionary.\n *\n * @public\n */\nexport function groupItemsBy<ArrayType, ReturnType extends string | number>(\n  array: ArrayType[],\n  groupBy: (item: ArrayType) => ReturnType\n): Record<ReturnType, ArrayType[]> {\n  return array.reduce<Record<ReturnType, ArrayType[]>>((accumulator, current) => {\n    const keyValue = groupBy(current);\n    if (!accumulator[keyValue]) {\n      accumulator[keyValue] = [];\n    }\n    accumulator[keyValue].push(current);\n    return accumulator;\n  }, {} as Record<ReturnType, ArrayType[]>);\n}\n\n/**\n * Filters an array with all elements that pass the test implemented by the provided filter\n * function. It also does it recursively if the property accessed, whose name is the parameter\n * childrenKey, to the current iteration in an array.\n *\n * @param array - Array to be filtered.\n * @param filter - Predicate function to test each element of the array. It should return true\n * to keep the element; or false otherwise.\n * @param childrenKey - Property name within the array used to perform a recursive call.\n *\n * @example\n * Input - Output example\n *\n * ```\n * const hierarchicalFilters: Filter[] = [\n *   {\n *     id: 'filter1'\n *     selected: true,\n *     children: [\n *       {\n *         id: 'filter1-1'\n *         selected: true,\n *         children: []\n *       },\n *       {\n *         id: 'filter1-2'\n *         selected: false,\n *         children: []\n *       }\n *     ]\n *   },\n *   {\n *     id: 'filter2',\n *     selected: false,\n *     children: [\n *      {\n *        id: 'filter2-1',\n *        selected: true // not should happen\n *      }\n *     ]\n *   }\n * ]\n *\n *  const filteredArray: Filter[] = deepFilterArray(\n *    hierarchicalFilters,\n *    filter => filter.selected,\n *    'children'\n *  )\n *\n *  /*\n *    filteredArray = [\n *      {\n *        id: 'filter1'\n *        selected: true,\n *        children: [\n *          {\n *            id: 'filter1-1'\n *            selected: true,\n *            children: []\n *          },\n *          {\n *            id: 'filter1-2'\n *            selected: false,\n *            children: []\n *          }\n *        ]\n *      },\n *      {\n *        id: 'filter1-1'\n *        selected: true,\n *        children: []\n *      }\n *    ]\n * ```\n *\n * @returns A new array with the elements that pass the test, or an empty array if no one\n * pass the test.\n *\n * @public\n */\nexport function deepFilter<ArrayType, Key extends PropsWithType<ArrayType, ArrayType[]>>(\n  array: ArrayType[],\n  filter: (item: ArrayType) => boolean,\n  childrenKey: Key\n): ArrayType[] {\n  const filterArray = function (\n    currentArray: ArrayType[],\n    initialArray: ArrayType[] = []\n  ): ArrayType[] {\n    return currentArray.reduce((result, currentItem) => {\n      if (filter(currentItem)) {\n        result.push(currentItem);\n        filterArray(currentItem[childrenKey], result);\n      }\n\n      return result;\n    }, initialArray);\n  };\n\n  return filterArray(array);\n}\n\n/**\n * Flat an ArrayType[] recursively using the childrenKey passed as parameter to access to his nested\n * child which is also ArrayType[].\n *\n * @param array - ArrayType[] which each ArrayType has a property childrenKey which value is also\n * an ArrayType[].\n * @param childrenKey - Key used to access to each ArrayType[childrenKey] value which is also\n * an ArrayType[].\n *\n * @returns ArrayType[] with all the nested ArrayType, including the nested ones, at the same depth\n * level.\n *\n * @public\n */\nexport function deepFlat<ArrayType, Key extends PropsWithType<ArrayType, ArrayType[] | undefined>>(\n  array: ArrayType[],\n  childrenKey: Key\n): ArrayType[] {\n  /**\n   * Flats an array recursively. In each iteration:\n   * - If the currentItem is an array, flatArray is used to reduce it. So, the order of the\n   * flatArray arguments defined is important. This happens when the function is called passing an\n   * array as the second parameter.\n   * - If not, the item is pushed to the resultantArray.\n   * - Finally, flatArray function is called again with the currentItem children and the process\n   * starts again.\n   *\n   * It's the main function of the parent. See the description above\n   * for further information.\n   *\n   * @param resultantArray - Flattened array.\n   * @param currentItem - ArrayType object.\n   *\n   * @returns Flattened ArrayType[].\n   *\n   * @internal\n   */\n  function flatArray(\n    resultantArray: ArrayType[],\n    currentItem: ArrayType | ArrayType[]\n  ): ArrayType[] {\n    if (!currentItem) {\n      return resultantArray;\n    }\n\n    if (Array.isArray(currentItem)) {\n      return currentItem.reduce(flatArray, resultantArray);\n    }\n    resultantArray.push(currentItem);\n    return flatArray(resultantArray, currentItem[childrenKey]);\n  }\n\n  return flatArray([], array);\n}\n"],"names":[],"mappings":"AAEA;;;;;;;SAOgB,YAAY,CAAC,KAAmC;IAC9D,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7C,CAAC;AAmCD;;;;;;;;;;;;;;;;SAgBgB,aAAa,CAC3B,KAAkB,EAClB,GAAuC;IAEvC,OAAO,KAAK,CAAC,MAAM,CAA4B,UAAC,WAAW,EAAE,OAAO;QAClE,IAAI,GAAG,EAAE;YACP,WAAW,CAAC,OAAO,CAAC,GAAG,CAAsB,CAAC,GAAG,OAAO,CAAC;SAC1D;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YACtC,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;SAChC;QACD,OAAO,WAAW,CAAC;KACpB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;;SAUgB,YAAY,CAC1B,KAAkB,EAClB,OAAwC;IAExC,OAAO,KAAK,CAAC,MAAM,CAAkC,UAAC,WAAW,EAAE,OAAO;QACxE,IAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE;YAC1B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;SAC5B;QACD,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,WAAW,CAAC;KACpB,EAAE,EAAqC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAgFgB,UAAU,CACxB,KAAkB,EAClB,MAAoC,EACpC,WAAgB;IAEhB,IAAM,WAAW,GAAG,UAClB,YAAyB,EACzB,YAA8B;QAA9B,6BAAA,EAAA,iBAA8B;QAE9B,OAAO,YAAY,CAAC,MAAM,CAAC,UAAC,MAAM,EAAE,WAAW;YAC7C,IAAI,MAAM,CAAC,WAAW,CAAC,EAAE;gBACvB,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;gBACzB,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,CAAC;aAC/C;YAED,OAAO,MAAM,CAAC;SACf,EAAE,YAAY,CAAC,CAAC;KAClB,CAAC;IAEF,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;;;;;;;;;;SAcgB,QAAQ,CACtB,KAAkB,EAClB,WAAgB;;;;;;;;;;;;;;;;;;;;IAqBhB,SAAS,SAAS,CAChB,cAA2B,EAC3B,WAAoC;QAEpC,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO,cAAc,CAAC;SACvB;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;YAC9B,OAAO,WAAW,CAAC,MAAM,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;SACtD;QACD,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACjC,OAAO,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;KAC5D;IAED,OAAO,SAAS,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AAC9B;;;;"}
+{"version":3,"file":"array.js","sources":["../../../src/utils/array.ts"],"sourcesContent":["import { PropsWithType } from './types';\n\n/**\n * Returns if the given array is `null`, `undefined`, or has no elements.\n *\n * @param array - The array to check if it is empty.\n * @returns `true` if the array is `null`, `undefined`, or has no elements. `false` otherwise.\n * @public\n */\nexport function isArrayEmpty(array: unknown[] | undefined | null): array is undefined | null | [] {\n  return array == null || array.length === 0;\n}\n\n/**\n * Reduce an array of strings to an object which properties names are the value of each string,\n * and the value under that property are also the string.\n *\n * @param array - Array of strings that will be used to create the object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the\n * array.\n *\n * @example Converting an array to an object:\n *         arrayToObject(['a', 'b', 'c']) === \\{a: 'a', b: 'b', c: 'c'\\}\n *\n * @public\n */\nexport function arrayToObject(array: string[]): Record<string, string>;\n/**\n * Reduce an array of objects to an object which properties names are the value of each object[key],\n * and the value under that property are each object. 'key' is the the parameter passed to this\n * function.\n *\n * @param array - Array of objects that contains objects which have object[key] string as a property\n * value.\n * @param key - Key used to access to each object[key] value, used for each property name in the new\n * object.\n *\n * @returns New object which properties object[key] contains object of each iteration in the array.\n *\n * @public\n */\nexport function arrayToObject<ArrayType>(\n  array: ArrayType[],\n  key: PropsWithType<ArrayType, string | number>\n): Record<string, ArrayType>;\n/**\n * Reduce an array to an object. The type of the object returned depends on the type of the params.\n * If the 'key' is passed then the function returns an object which properties names are the value\n * of each object[key] and the value under that property are each object.\n * If the 'key' is not passed then the function returns an object which properties names are each\n * array item, and the value is also the array item.\n *\n * @param array - Array from which to create an object.\n * @param key - Key used to access to each object[key] value, used for each property name in the\n * new object.\n *\n * @returns New object which properties object[key] contains each item in the array and the key is\n * either the item of the array or a property of each item designated by 'key' param.\n *\n * @public\n */\nexport function arrayToObject<ArrayType>(\n  array: ArrayType[],\n  key?: PropsWithType<ArrayType, string | number>\n): Record<string, ArrayType> {\n  return array.reduce<Record<string, ArrayType>>((accumulator, current) => {\n    if (key) {\n      accumulator[current[key] as any] = current;\n    } else if (typeof current === 'string') {\n      accumulator[current] = current;\n    }\n    return accumulator;\n  }, {});\n}\n\n/**\n * Groups the array items based on the provided `groupBy` function.\n *\n * @param array - The array to iterate, grouping its items in different arrays based on the\n * `groupBy` function.\n * @param groupBy - A function to determine the group name of a single item.\n * @returns The items grouped in a dictionary.\n *\n * @public\n */\nexport function groupItemsBy<ArrayType, ReturnType extends string | number>(\n  array: ArrayType[],\n  groupBy: (item: ArrayType, index: number) => ReturnType\n): Record<ReturnType, ArrayType[]> {\n  return array.reduce<Record<ReturnType, ArrayType[]>>((accumulator, current, index) => {\n    const keyValue = groupBy(current, index);\n    if (!accumulator[keyValue]) {\n      accumulator[keyValue] = [];\n    }\n    accumulator[keyValue].push(current);\n    return accumulator;\n  }, {} as Record<ReturnType, ArrayType[]>);\n}\n\n/**\n * Filters an array with all elements that pass the test implemented by the given filter\n * function. If an item has another list of items in the `childrenKey` property it recursively\n * filters that new list, adding it to the returned one.\n *\n * @param array - Array to be filtered.\n * @param condition - Predicate function to test each element of the array. It should return `true`\n * to keep the element; or `false` otherwise.\n * @param childrenKey - Property name within the array used to perform a recursive call.\n *\n * @example\n * Input - Output example\n *\n * ```\n * const hierarchicalFilters: Filter[] = [\n *   {\n *     id: 'filter1'\n *     selected: true,\n *     children: [\n *       {\n *         id: 'filter1-1'\n *         selected: true,\n *         children: []\n *       },\n *       {\n *         id: 'filter1-2'\n *         selected: false,\n *         children: []\n *       }\n *     ]\n *   },\n *   {\n *     id: 'filter2',\n *     selected: false,\n *     children: [\n *      {\n *        id: 'filter2-1',\n *        selected: true // not should happen\n *      }\n *     ]\n *   }\n * ]\n *\n *  const filteredArray: Filter[] = deepFilterArray(\n *    hierarchicalFilters,\n *    filter => filter.selected,\n *    'children'\n *  )\n *\n *  /*\n *    filteredArray = [\n *      {\n *        id: 'filter1'\n *        selected: true,\n *        children: [\n *          {\n *            id: 'filter1-1'\n *            selected: true,\n *            children: []\n *          },\n *          {\n *            id: 'filter1-2'\n *            selected: false,\n *            children: []\n *          }\n *        ]\n *      },\n *      {\n *        id: 'filter1-1'\n *        selected: true,\n *        children: []\n *      }\n *    ]\n * ```\n *\n * @returns A new array with the elements that pass the condition, or an empty array if no one\n * pass the test.\n *\n * @public\n */\nexport function deepFilter<Item extends { [key in Key]?: Item[] }, Key extends keyof Item>(\n  array: Item[],\n  condition: (item: Item) => boolean,\n  childrenKey: Key\n): Item[] {\n  return array.reduce<Item[]>(function filter(filteredArray, item) {\n    if (condition(item)) {\n      filteredArray.push(item);\n      item[childrenKey]?.reduce(filter, filteredArray);\n    }\n    return filteredArray;\n  }, []);\n}\n\n/**\n * Flat an `Item[]` deeply using the given `childrenKey` to access to his children.\n *\n * @param array - The list of items to flat. Each item may have another list of items of\n * the same type to flat.\n * @param childrenKey - Property name where each of the items of the given array may have another\n * list of items to be flattened.\n *\n * @returns A flat list with all the found items.\n *\n * @public\n */\nexport function deepFlat<Item extends { [key in Key]?: Item[] }, Key extends keyof Item>(\n  array: Item[],\n  childrenKey: Key\n): Item[] {\n  return array.reduce<Item[]>(function flat(flattenedArray, item) {\n    flattenedArray.push(item);\n    item[childrenKey]?.reduce(flat, flattenedArray);\n    return flattenedArray;\n  }, []);\n}\n\n/**\n * Creates an Emitter filter function to compare two arrays and filter those that are equal.\n *\n * @param comparator - String with the name of the field of the arrays items to compare, or function\n * to compare items directly.\n * @returns The comparator function that receives two arrays to compare them.\n *\n * @internal\n */\nexport function createEmitterArrayFilter<T>(\n  comparator: keyof T | ((item1: T, item2: T) => boolean)\n): (newCollection: Array<T>, oldCollection: Array<T>) => boolean {\n  const comparatorFn =\n    typeof comparator === 'function'\n      ? comparator\n      : (newItem: T, oldItem: T) => newItem[comparator] === oldItem[comparator];\n  return function (newCollection: Array<T>, oldCollection: Array<T>): boolean {\n    return (\n      newCollection.length !== oldCollection.length ||\n      newCollection.some(newItem => !oldCollection.find(oldItem => comparatorFn(newItem, oldItem)))\n    );\n  };\n}\n"],"names":[],"mappings":"AAEA;;;;;;;SAOgB,YAAY,CAAC,KAAmC;IAC9D,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAC7C,CAAC;AAmCD;;;;;;;;;;;;;;;;SAgBgB,aAAa,CAC3B,KAAkB,EAClB,GAA+C;IAE/C,OAAO,KAAK,CAAC,MAAM,CAA4B,CAAC,WAAW,EAAE,OAAO;QAClE,IAAI,GAAG,EAAE;YACP,WAAW,CAAC,OAAO,CAAC,GAAG,CAAQ,CAAC,GAAG,OAAO,CAAC;SAC5C;aAAM,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;YACtC,WAAW,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;SAChC;QACD,OAAO,WAAW,CAAC;KACpB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;;SAUgB,YAAY,CAC1B,KAAkB,EAClB,OAAuD;IAEvD,OAAO,KAAK,CAAC,MAAM,CAAkC,CAAC,WAAW,EAAE,OAAO,EAAE,KAAK;QAC/E,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE;YAC1B,WAAW,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;SAC5B;QACD,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,WAAW,CAAC;KACpB,EAAE,EAAqC,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAgFgB,UAAU,CACxB,KAAa,EACb,SAAkC,EAClC,WAAgB;IAEhB,OAAO,KAAK,CAAC,MAAM,CAAS,SAAS,MAAM,CAAC,aAAa,EAAE,IAAI;QAC7D,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE;YACnB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;SAClD;QACD,OAAO,aAAa,CAAC;KACtB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;;;;SAYgB,QAAQ,CACtB,KAAa,EACb,WAAgB;IAEhB,OAAO,KAAK,CAAC,MAAM,CAAS,SAAS,IAAI,CAAC,cAAc,EAAE,IAAI;QAC5D,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QAChD,OAAO,cAAc,CAAC;KACvB,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED;;;;;;;;;SASgB,wBAAwB,CACtC,UAAuD;IAEvD,MAAM,YAAY,GAChB,OAAO,UAAU,KAAK,UAAU;UAC5B,UAAU;UACV,CAAC,OAAU,EAAE,OAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9E,OAAO,UAAU,aAAuB,EAAE,aAAuB;QAC/D,QACE,aAAa,CAAC,MAAM,KAAK,aAAa,CAAC,MAAM;YAC7C,aAAa,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAC7F;KACH,CAAC;AACJ;;;;"}

package/js/utils/cancellable-promise.js

@@ -5,7 +5,7 @@ import { noOp } from './function.js';
  *
  * @internal
  */
-var CancelSymbol = Symbol('cancelled-promise');
+const CancelSymbol = Symbol('cancelled-promise');
 /**
  * Util function that returns an object which contains a promise, result of Promise.race call
  * between the original one passed as parameter and another one, created within the function, used
@@ -27,16 +27,16 @@ var CancelSymbol = Symbol('cancelled-promise');
  * @internal
  */
 function cancellablePromise(promise, cancelCallback) {
-    var cancel = noOp;
-    var cancelPromise = new Promise(function (_, reject) {
-        cancel = function (payload) {
+    let cancel = noOp;
+    const cancelPromise = new Promise((_, reject) => {
+        cancel = payload => {
             reject(CancelSymbol);
-            cancelCallback === null || cancelCallback === void 0 ? void 0 : cancelCallback(payload);
+            cancelCallback?.(payload);
         };
     });
     return {
         promise: Promise.race([promise, cancelPromise]),
-        cancel: cancel
+        cancel
     };
 }
 

package/js/utils/cancellable-promise.js.map

@@ -1 +1 @@
-{"version":3,"file":"cancellable-promise.js","sources":["../../../src/utils/cancellable-promise.ts"],"sourcesContent":["import { noOp } from './function';\n/**\n * Symbol used to know if a promise is cancelled.\n *\n * @internal\n */\nexport const CancelSymbol = Symbol('cancelled-promise');\n/**\n * The type returned by the {@link cancellablePromise} function.\n *\n * @internal\n */\nexport interface CancellablePromiseFunction<T, K = unknown> {\n  /**\n   * The resultant promise that groups the original promise, passed as the first parameter, and the\n   * promise created in cancellablePromise, which rejects the resultant promise if called.\n   */\n  promise: Promise<T>;\n  /**\n   * Function to cancel the resultant promise. This function triggers the reject of the second\n   * promise of the promise race. The first parameter is the resultant promise rejection value.\n   */\n  cancel: (payload?: K) => void;\n}\n\n/**\n * Util function that returns an object which contains a promise, result of Promise.race call\n * between the original one passed as parameter and another one, created within the function, used\n * for reject in the resultant promise manually. If the cancel method is triggered, the\n * resultant promise is rejected.\n *\n * @remarks The promise function passed as first param executes its own async code ALWAYS although\n * it's cancelled or not. The payload of the resultant promise is the returned by the function that\n * ends first. So, the promise is not cancelled exactly. The parameter first passed to cancel is the\n * resultant promise rejection value.\n *\n * If you need to check if the promise is not being rejected with CancelSymbol (on purpose).\n * You should check the error type in the cancellable catch using the payload.\n *\n * @param promise - Original promise.\n * @param cancelCallback - Optional callback to be called on cancel.\n * @returns CancellablePromiseFunction {@link CancellablePromiseFunction}.\n *\n * @internal\n */\nexport function cancellablePromise<T, K = unknown>(\n  promise: Promise<T>,\n  cancelCallback?: (payload?: K) => void\n): CancellablePromiseFunction<T, K> {\n  let cancel: (payload?: K) => void = noOp;\n\n  const cancelPromise = new Promise<never>((_, reject) => {\n    cancel = payload => {\n      reject(CancelSymbol);\n      cancelCallback?.(payload);\n    };\n  });\n\n  return {\n    promise: Promise.race([promise, cancelPromise]),\n    cancel\n  };\n}\n"],"names":[],"mappings":";;AACA;;;;;IAKa,YAAY,GAAG,MAAM,CAAC,mBAAmB,EAAE;AAmBxD;;;;;;;;;;;;;;;;;;;;SAoBgB,kBAAkB,CAChC,OAAmB,EACnB,cAAsC;IAEtC,IAAI,MAAM,GAA0B,IAAI,CAAC;IAEzC,IAAM,aAAa,GAAG,IAAI,OAAO,CAAQ,UAAC,CAAC,EAAE,MAAM;QACjD,MAAM,GAAG,UAAA,OAAO;YACd,MAAM,CAAC,YAAY,CAAC,CAAC;YACrB,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAG,OAAO,EAAE;SAC3B,CAAC;KACH,CAAC,CAAC;IAEH,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/C,MAAM,QAAA;KACP,CAAC;AACJ;;;;"}
+{"version":3,"file":"cancellable-promise.js","sources":["../../../src/utils/cancellable-promise.ts"],"sourcesContent":["import { noOp } from './function';\n/**\n * Symbol used to know if a promise is cancelled.\n *\n * @internal\n */\nexport const CancelSymbol = Symbol('cancelled-promise');\n/**\n * The type returned by the {@link cancellablePromise} function.\n *\n * @internal\n */\nexport interface CancellablePromiseFunction<T, K = unknown> {\n  /**\n   * The resultant promise that groups the original promise, passed as the first parameter, and the\n   * promise created in cancellablePromise, which rejects the resultant promise if called.\n   */\n  promise: Promise<T>;\n  /**\n   * Function to cancel the resultant promise. This function triggers the reject of the second\n   * promise of the promise race. The first parameter is the resultant promise rejection value.\n   */\n  cancel: (payload?: K) => void;\n}\n\n/**\n * Util function that returns an object which contains a promise, result of Promise.race call\n * between the original one passed as parameter and another one, created within the function, used\n * for reject in the resultant promise manually. If the cancel method is triggered, the\n * resultant promise is rejected.\n *\n * @remarks The promise function passed as first param executes its own async code ALWAYS although\n * it's cancelled or not. The payload of the resultant promise is the returned by the function that\n * ends first. So, the promise is not cancelled exactly. The parameter first passed to cancel is the\n * resultant promise rejection value.\n *\n * If you need to check if the promise is not being rejected with CancelSymbol (on purpose).\n * You should check the error type in the cancellable catch using the payload.\n *\n * @param promise - Original promise.\n * @param cancelCallback - Optional callback to be called on cancel.\n * @returns CancellablePromiseFunction {@link CancellablePromiseFunction}.\n *\n * @internal\n */\nexport function cancellablePromise<T, K = unknown>(\n  promise: Promise<T>,\n  cancelCallback?: (payload?: K) => void\n): CancellablePromiseFunction<T, K> {\n  let cancel: (payload?: K) => void = noOp;\n\n  const cancelPromise = new Promise<never>((_, reject) => {\n    cancel = payload => {\n      reject(CancelSymbol);\n      cancelCallback?.(payload);\n    };\n  });\n\n  return {\n    promise: Promise.race([promise, cancelPromise]),\n    cancel\n  };\n}\n"],"names":[],"mappings":";;AACA;;;;;MAKa,YAAY,GAAG,MAAM,CAAC,mBAAmB,EAAE;AAmBxD;;;;;;;;;;;;;;;;;;;;SAoBgB,kBAAkB,CAChC,OAAmB,EACnB,cAAsC;IAEtC,IAAI,MAAM,GAA0B,IAAI,CAAC;IAEzC,MAAM,aAAa,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM;QACjD,MAAM,GAAG,OAAO;YACd,MAAM,CAAC,YAAY,CAAC,CAAC;YACrB,cAAc,GAAG,OAAO,CAAC,CAAC;SAC3B,CAAC;KACH,CAAC,CAAC;IAEH,OAAO;QACL,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC/C,MAAM;KACP,CAAC;AACJ;;;;"}