@capillarytech/blaze-ui 6.4.0 → 6.5.0

package/CapVirtualSelect/index.js

@@ -0,0 +1,409 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import classNames from "classnames";
+import debounce from "lodash/debounce";
+import get from "lodash/get";
+import PropTypes from "prop-types";
+import { useState, useRef, useCallback, useEffect } from "react";
+import { intlShape, FormattedMessage, injectIntl } from "react-intl";
+import { connect } from "react-redux";
+import { Virtuoso } from "react-virtuoso";
+import { compose, bindActionCreators } from "redux";
+import { createStructuredSelector } from "reselect";
+import CapIcon from "../CapIcon/index.js";
+import CapSearch from "../CapInput/Search.js";
+import CapRow from "../CapRow/index.js";
+import CapSpin from "../CapSpin/index.js";
+import clearDataOnUnmount from "../ClearDataOnUnmountHoc/index.js";
+import * as CapVirtualSelect_actions from "./actions.js";
+import { defaultNamespace, dataTestIdPrefix, SUCCESS, FAILURE, REQUEST } from "./constants.js";
+import messages from "./messages.js";
+import { makeSelectGetOptionById, makeSelectGetPaginatedOptions } from "./selectors.js";
+import './styles.css';/* empty css            */
+import { convertApiParamsMapperToObject } from "./utils.js";
+const classPrefix = "cap-virtual-select";
+const NoOptionsFound = () => {
+  return /* @__PURE__ */ jsxs(
+    CapRow,
+    {
+      className: classNames(`${classPrefix}-no-options`),
+      "data-testid": `${dataTestIdPrefix}-no-options`,
+      children: [
+        /* @__PURE__ */ jsx(CapIcon, { className: classNames(`${classPrefix}-no-options-image`), type: "alert" }),
+        /* @__PURE__ */ jsx(CapRow, { className: classNames(`${classPrefix}-no-options-text`), children: /* @__PURE__ */ jsx(FormattedMessage, { ...messages.noOptionsFound }) })
+      ]
+    }
+  );
+};
+function CapVirtualSelect({
+  intl: { formatMessage: _formatMessage },
+  namespace: _namespace,
+  listingApiConfig,
+  getByIdApiConfig,
+  selectedOption,
+  isSearchable,
+  searchDebounceTime,
+  disabled,
+  selectedOptionPlaceholderLabel,
+  searchPlaceholderLabel,
+  loadingOptionsPlaceholder,
+  EmptyPlaceholder,
+  EmptySearchPlaceholder,
+  width,
+  height,
+  buttonProps,
+  searchbarProps,
+  virtuosoProps,
+  onOptionClick,
+  renderOptionRow,
+  renderSelectedOptionRow,
+  transformOptions,
+  actions: actions2,
+  paginatedOptions: {
+    getPaginatedOptionsStatus,
+    getPaginatedOptions,
+    getUnTransformedPaginatedOptions,
+    getPaginatedOptionsTotalCount
+  },
+  optionById: { getOptionByIdStatus, getOptionById }
+}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const [isDropdownVisible, setIsDropdownListVisible] = useState(false);
+  const [listingApiQueryParams, setListingApiQueryParams] = useState(
+    () => convertApiParamsMapperToObject(listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper)
+  );
+  const [defaultSelectedOption, _setDefaultSelectedOption] = useState(() => selectedOption);
+  const [selectedOptionNode, setSelectedOptionNode] = useState({});
+  const [searchValue, setSearchValue] = useState("");
+  const [basePageIndex, setBasePageIndex] = useState(
+    () => {
+      var _a2, _b2;
+      return (_b2 = (_a2 = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _a2.page) == null ? void 0 : _b2.value;
+    }
+  );
+  const dropdownRef = useRef(null);
+  const searchKey = (_b = (_a = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _a.search) == null ? void 0 : _b.key;
+  const pageKey = (_d = (_c = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _c.page) == null ? void 0 : _d.key;
+  const pageValue = (_f = (_e = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _e.page) == null ? void 0 : _f.value;
+  const areOptionsLoading = getPaginatedOptionsStatus === REQUEST || getOptionByIdStatus === REQUEST;
+  const handleOptionChange = (selectedOptionNodeValue) => {
+    setSelectedOptionNode(selectedOptionNodeValue);
+    onOptionClick(selectedOptionNodeValue);
+    setIsDropdownListVisible(false);
+  };
+  const handleDebouncedSearch = useCallback(
+    debounce((value) => {
+      setListingApiQueryParams((prevState) => ({
+        ...prevState,
+        [searchKey]: value,
+        [pageKey]: pageValue
+      }));
+    }, searchDebounceTime),
+    []
+  );
+  const handleSearchChange = (value) => {
+    setSearchValue(value);
+    if (searchValue) {
+      handleDebouncedSearch(value);
+    }
+  };
+  const handleLoadMoreOptions = () => {
+    const loadedUnTransformedPaginatedOptionsLength = (getUnTransformedPaginatedOptions == null ? void 0 : getUnTransformedPaginatedOptions.length) || 0;
+    const loadedPaginatedOptionsLength = defaultSelectedOption && !searchValue ? loadedUnTransformedPaginatedOptionsLength + 1 : loadedUnTransformedPaginatedOptionsLength;
+    const areAllOptionsLoaded = loadedPaginatedOptionsLength === getPaginatedOptionsTotalCount;
+    if (areOptionsLoading || areAllOptionsLoaded || getPaginatedOptionsStatus === FAILURE) return;
+    setListingApiQueryParams((prevState) => ({
+      ...prevState,
+      [pageKey]: prevState[pageKey] + 1
+    }));
+  };
+  const renderVisibleOptionNodes = (index, visibleNode) => {
+    var _a2, _b2;
+    const selectedOptionValue = get(selectedOptionNode, (_a2 = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _a2.value, "");
+    const currentSelectedOptionValue = get(visibleNode, (_b2 = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _b2.value, "");
+    return /* @__PURE__ */ jsx(
+      CapRow,
+      {
+        onClick: (event) => {
+          event.stopPropagation();
+          handleOptionChange(visibleNode);
+        },
+        className: classNames(
+          selectedOptionValue === currentSelectedOptionValue ? `${classPrefix}-selected-option-row` : `${classPrefix}-option-row`
+        ),
+        "data-testid": `${dataTestIdPrefix}-option-row`,
+        children: renderOptionRow(visibleNode)
+      },
+      index
+    );
+  };
+  useEffect(() => {
+    if (selectedOption) {
+      const getByIdApiQueryParams = convertApiParamsMapperToObject(
+        getByIdApiConfig == null ? void 0 : getByIdApiConfig.apiParamsMapper
+      );
+      actions2.getOptionById(selectedOption, getByIdApiConfig, getByIdApiQueryParams);
+    }
+    setBasePageIndex(convertApiParamsMapperToObject(listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper)[pageKey]);
+  }, []);
+  useEffect(() => {
+    if ([SUCCESS, FAILURE].includes(getOptionByIdStatus)) {
+      setSelectedOptionNode(getOptionById);
+    }
+  }, [getOptionByIdStatus]);
+  useEffect(() => {
+    if (areOptionsLoading || listingApiQueryParams[pageKey] > (listingApiConfig == null ? void 0 : listingApiConfig.rpmLimit)) return;
+    if (!defaultSelectedOption || defaultSelectedOption && [SUCCESS, FAILURE].includes(getOptionByIdStatus)) {
+      actions2.getPaginatedOptions(listingApiConfig, listingApiQueryParams, transformOptions);
+    }
+  }, [listingApiQueryParams[pageKey], listingApiQueryParams[searchKey], getOptionByIdStatus]);
+  useEffect(() => {
+    const handleClickOutside = (event) => {
+      var _a2;
+      if (!((_a2 = dropdownRef.current) == null ? void 0 : _a2.contains(event.target))) {
+        setIsDropdownListVisible(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, []);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: dropdownRef,
+      className: classNames(`${classPrefix}-container`),
+      style: { width },
+      "data-testid": `${dataTestIdPrefix}-container`,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            className: classNames(`${classPrefix}-button`, {
+              [`${classPrefix}-button-disabled`]: disabled || areOptionsLoading
+            }),
+            "data-testid": `${dataTestIdPrefix}-button`,
+            onClick: () => setIsDropdownListVisible(true),
+            disabled: disabled || areOptionsLoading,
+            ...buttonProps,
+            children: [
+              /* @__PURE__ */ jsx(CapRow, { className: classNames(`${classPrefix}-button-label`), children: areOptionsLoading && !(listingApiQueryParams[pageKey] > basePageIndex) ? /* @__PURE__ */ jsx(CapRow, { children: loadingOptionsPlaceholder }) : /* @__PURE__ */ jsx(
+                CapRow,
+                {
+                  className: classNames({
+                    [`${classPrefix}-button-defined-label`]: get(
+                      selectedOptionNode,
+                      (_g = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _g.label,
+                      selectedOptionPlaceholderLabel
+                    ) !== selectedOptionPlaceholderLabel
+                  }),
+                  children: renderSelectedOptionRow(
+                    selectedOptionNode,
+                    get(
+                      selectedOptionNode,
+                      (_h = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _h.label,
+                      selectedOptionPlaceholderLabel
+                    )
+                  )
+                }
+              ) }),
+              /* @__PURE__ */ jsx(CapIcon, { type: "chevron-down", className: classNames(`${classPrefix}-button-arrow`) })
+            ]
+          }
+        ),
+        isDropdownVisible && /* @__PURE__ */ jsxs(
+          CapRow,
+          {
+            className: classNames(`${classPrefix}-dropdown`),
+            style: { width },
+            "data-testid": `${dataTestIdPrefix}-dropdown`,
+            children: [
+              isSearchable && /* @__PURE__ */ jsx(
+                CapSearch,
+                {
+                  className: classNames(`${classPrefix}-search-bar`),
+                  "data-testid": `${dataTestIdPrefix}-search-bar`,
+                  value: searchValue,
+                  onChange: (event) => handleSearchChange(event.target.value),
+                  placeholder: searchPlaceholderLabel,
+                  allowClear: false,
+                  ...searchbarProps
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                CapSpin,
+                {
+                  className: classNames(`${classPrefix}-options-list-spinner`),
+                  size: "small",
+                  spinning: areOptionsLoading,
+                  children: /* @__PURE__ */ jsx(
+                    Virtuoso,
+                    {
+                      style: { width, height: isSearchable ? height : height + 64 },
+                      className: classNames(`${classPrefix}-options-list`),
+                      "data-testid": `${dataTestIdPrefix}-options-list`,
+                      totalCount: getPaginatedOptions == null ? void 0 : getPaginatedOptions.length,
+                      data: getPaginatedOptions,
+                      endReached: handleLoadMoreOptions,
+                      itemContent: renderVisibleOptionNodes,
+                      components: {
+                        EmptyPlaceholder: searchValue ? EmptySearchPlaceholder : EmptyPlaceholder
+                      },
+                      ...virtuosoProps
+                    }
+                  )
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+CapVirtualSelect.propTypes = {
+  intl: intlShape.isRequired,
+  namespace: PropTypes.string,
+  listingApiConfig: PropTypes.objectOf(
+    PropTypes.shape({
+      method: PropTypes.func,
+      rpmLimit: PropTypes.number,
+      payloadPath: PropTypes.objectOf(
+        PropTypes.shape({
+          successStatus: PropTypes.string,
+          success: PropTypes.string,
+          error: PropTypes.string,
+          label: PropTypes.string,
+          value: PropTypes.string,
+          totalCount: PropTypes.string
+        })
+      ),
+      apiParamsMapper: PropTypes.objectOf(
+        PropTypes.shape({
+          page: { key: PropTypes.string, value: PropTypes.any },
+          limit: { key: PropTypes.string, value: PropTypes.any },
+          search: { key: PropTypes.string, value: PropTypes.any }
+        })
+      )
+    })
+  ),
+  getByIdApiConfig: PropTypes.objectOf(
+    PropTypes.shape({
+      method: PropTypes.func,
+      rpmLimit: PropTypes.number,
+      payloadPath: PropTypes.objectOf(
+        PropTypes.shape({
+          successStatus: PropTypes.string,
+          success: PropTypes.string,
+          error: PropTypes.string,
+          value: PropTypes.string
+        })
+      ),
+      apiParamsMapper: PropTypes.objectOf(
+        PropTypes.shape({
+          page: { key: PropTypes.string, value: PropTypes.any },
+          limit: { key: PropTypes.string, value: PropTypes.any },
+          search: { key: PropTypes.string, value: PropTypes.any }
+        })
+      )
+    })
+  ),
+  selectedOption: PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.bool]),
+  isSearchable: PropTypes.bool,
+  searchDebounceTime: PropTypes.number,
+  disabled: PropTypes.bool,
+  selectedOptionPlaceholderLabel: PropTypes.string,
+  searchPlaceholderLabel: PropTypes.string,
+  loadingOptionsPlaceholder: PropTypes.string,
+  width: PropTypes.number,
+  height: PropTypes.number,
+  buttonProps: PropTypes.object,
+  searchbarProps: PropTypes.object,
+  virtuosoProps: PropTypes.object,
+  transformOptions: PropTypes.func,
+  renderOptionRow: PropTypes.func,
+  renderSelectedOptionRow: PropTypes.func,
+  onOptionClick: PropTypes.func,
+  EmptyPlaceholder: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),
+  EmptySearchPlaceholder: PropTypes.oneOfType([PropTypes.func, PropTypes.node])
+};
+CapVirtualSelect.defaultProps = {
+  intl: intlShape.isRequired,
+  namespace: defaultNamespace,
+  listingApiConfig: {
+    method: () => Promise.resolve([]),
+    rpmLimit: 20,
+    payloadPath: {
+      successStatus: "success",
+      success: "data",
+      error: "error",
+      label: "name",
+      value: "id",
+      totalCount: "totalCount"
+    },
+    apiParamsMapper: {
+      page: { key: "page", value: 0 },
+      limit: { key: "limit", value: 10 },
+      search: { key: "search", value: "" }
+    }
+  },
+  getByIdApiConfig: {
+    method: () => Promise.resolve(null),
+    rpmLimit: 20,
+    payloadPath: {
+      successStatus: "success",
+      success: "data",
+      error: "error",
+      value: "id"
+    },
+    apiParamsMapper: {}
+  },
+  selectedOption: null,
+  isSearchable: false,
+  searchDebounceTime: 1500,
+  disabled: false,
+  selectedOptionPlaceholderLabel: "Select an option",
+  searchPlaceholderLabel: "Search",
+  loadingOptionsPlaceholder: "Loading options...",
+  width: 250,
+  height: 188,
+  buttonProps: {},
+  searchbarProps: {},
+  virtuosoProps: {},
+  transformOptions: (options) => options,
+  onOptionClick: (option) => option,
+  renderOptionRow: (option) => /* @__PURE__ */ jsx("div", { children: (option == null ? void 0 : option.name) || "N/A" }),
+  renderSelectedOptionRow: (selectedOption, selectedOptionValue) => /* @__PURE__ */ jsx("div", { children: selectedOptionValue }),
+  EmptyPlaceholder: NoOptionsFound,
+  EmptySearchPlaceholder: NoOptionsFound
+};
+const CapVirtualSelectInjected = (namespace = defaultNamespace) => {
+  const mapStateToProps = createStructuredSelector({
+    paginatedOptions: makeSelectGetPaginatedOptions(),
+    optionById: makeSelectGetOptionById()
+  });
+  function mapDispatchToProps(dispatch) {
+    const updatedActions = {
+      ...CapVirtualSelect_actions
+    };
+    const allActions = Object.keys(updatedActions);
+    allActions.forEach((actionName) => {
+      const actionCreator = updatedActions[actionName];
+      updatedActions[actionName] = (...args) => {
+        const actionReturnValue = actionCreator(...args);
+        actionReturnValue.namespace = namespace;
+        return actionReturnValue;
+      };
+    });
+    return {
+      actions: bindActionCreators(updatedActions, dispatch)
+    };
+  }
+  const withConnect = connect(mapStateToProps, mapDispatchToProps);
+  return compose(withConnect)(injectIntl(clearDataOnUnmount(CapVirtualSelect)));
+};
+export {
+  CapVirtualSelect,
+  CapVirtualSelectInjected,
+  CapVirtualSelectInjected as default
+};

package/CapVirtualSelect/messages.d.ts

@@ -0,0 +1,9 @@
+export declare const scope = "app.commonUtils.capUiLibrary.CapVirtualSelect";
+declare const _default: {
+    noOptionsFound: {
+        id: string;
+        defaultMessage: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=messages.d.ts.map

package/CapVirtualSelect/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../components/CapVirtualSelect/messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,kDAAkD,CAAC;;;;;;;AAErE,wBAKG"}

package/CapVirtualSelect/messages.js

@@ -0,0 +1,12 @@
+import { defineMessages } from "react-intl";
+const scope = "app.commonUtils.capUiLibrary.CapVirtualSelect";
+const messages = defineMessages({
+  noOptionsFound: {
+    id: `${scope}.noOptionsFound`,
+    defaultMessage: "No options found!"
+  }
+});
+export {
+  messages as default,
+  scope
+};

package/CapVirtualSelect/reducer.d.ts

@@ -0,0 +1,4 @@
+export declare const initialState: import("immutable").Map<"getPaginatedOptionsStatus" | "getPaginatedOptions" | "getUnTransformedPaginatedOptions" | "getPaginatedOptionsError" | "getPaginatedOptionsTotalCount" | "getOptionByIdStatus" | "getOptionById" | "getOptionByIdError", any>;
+declare function CapVirtualSelectRootReducer(namespace?: string): (state: import("immutable").Map<"getPaginatedOptionsStatus" | "getPaginatedOptions" | "getUnTransformedPaginatedOptions" | "getPaginatedOptionsError" | "getPaginatedOptionsTotalCount" | "getOptionByIdStatus" | "getOptionById" | "getOptionByIdError", any>, action: any) => import("immutable").Map<"getPaginatedOptionsStatus" | "getPaginatedOptions" | "getUnTransformedPaginatedOptions" | "getPaginatedOptionsError" | "getPaginatedOptionsTotalCount" | "getOptionByIdStatus" | "getOptionById" | "getOptionByIdError", any>;
+export default CapVirtualSelectRootReducer;
+//# sourceMappingURL=reducer.d.ts.map

package/CapVirtualSelect/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../components/CapVirtualSelect/reducer.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY,wPASvB,CAAC;AAGH,iBAAS,2BAA2B,CAAC,SAAS,SAAyB,IAC7B,6PAAoB,EAAE,WAAM,4PAgFrE;AAED,eAAe,2BAA2B,CAAC"}

package/CapVirtualSelect/reducer.js

@@ -0,0 +1,63 @@
+import { fromJS } from "immutable";
+import isEmpty from "lodash/isEmpty";
+import uniqBy from "lodash/uniqBy";
+import * as CapVirtualSelect_constants from "./constants.js";
+import { defaultNamespace, CLEAR_DATA_ON_UNMOUNT, GET_OPTION_BY_ID_FAILURE, GET_OPTION_BY_ID_SUCCESS, GET_OPTION_BY_ID_REQUEST, GET_PAGINATED_OPTIONS_FAILURE, GET_PAGINATED_OPTIONS_SUCCESS, GET_PAGINATED_OPTIONS_REQUEST } from "./constants.js";
+const { REQUEST, SUCCESS, FAILURE } = CapVirtualSelect_constants;
+const initialState = fromJS({
+  getPaginatedOptionsStatus: "",
+  getPaginatedOptions: [],
+  getUnTransformedPaginatedOptions: [],
+  getPaginatedOptionsError: null,
+  getPaginatedOptionsTotalCount: 0,
+  getOptionByIdStatus: "",
+  getOptionById: {},
+  getOptionByIdError: null
+});
+function CapVirtualSelectRootReducer(namespace = defaultNamespace) {
+  return function CapVirtualSelectReducer(state = initialState, action) {
+    if ((action == null ? void 0 : action.namespace) !== namespace) {
+      return state;
+    }
+    switch (action.type) {
+      case GET_PAGINATED_OPTIONS_REQUEST:
+        return state.set("getPaginatedOptionsStatus", REQUEST).set("getPaginatedOptionsError", null);
+      case GET_PAGINATED_OPTIONS_SUCCESS: {
+        const getSelectedOption = state.get("getOptionByIdStatus") === SUCCESS ? state.get("getOptionById").toJS() : {};
+        const existingOptions = state.get("getPaginatedOptions").toJS();
+        const existingUnTransformedOptions = state.get("getUnTransformedPaginatedOptions").toJS();
+        const selectedValueKey = action == null ? void 0 : action.selectedValueKey;
+        const isSelectedOptionDefined = !isEmpty(getSelectedOption) && !(action == null ? void 0 : action.isSearchValueDefined);
+        const optionsCount = (action == null ? void 0 : action.totalCount) || 0;
+        const totalOptionsCount = isSelectedOptionDefined ? optionsCount + 1 : optionsCount;
+        const actionResult = action && action.result ? action.result : [];
+        const paginatedOptions = action && action.appendOptions ? uniqBy([...existingOptions, ...actionResult], selectedValueKey) : uniqBy(
+          [...isSelectedOptionDefined ? [getSelectedOption] : [], ...actionResult],
+          selectedValueKey
+        );
+        const unTransformedPaginatedOptions = action && action.appendOptions ? uniqBy([...existingUnTransformedOptions, ...actionResult], selectedValueKey) : uniqBy(
+          [...isSelectedOptionDefined ? [getSelectedOption] : [], ...actionResult],
+          selectedValueKey
+        );
+        const transformedOptions = (action == null ? void 0 : action.transformOptions) ? action.transformOptions(paginatedOptions) : paginatedOptions;
+        return state.set("getPaginatedOptionsStatus", SUCCESS).set("getPaginatedOptions", fromJS(transformedOptions)).set("getUnTransformedPaginatedOptions", fromJS(unTransformedPaginatedOptions)).set("getPaginatedOptionsTotalCount", totalOptionsCount).set("getPaginatedOptionsError", null);
+      }
+      case GET_PAGINATED_OPTIONS_FAILURE:
+        return state.set("getPaginatedOptionsStatus", FAILURE).set("getPaginatedOptionsError", action.error);
+      case GET_OPTION_BY_ID_REQUEST:
+        return state.set("getOptionByIdStatus", REQUEST).set("getOptionById", fromJS({})).set("getOptionByIdError", null);
+      case GET_OPTION_BY_ID_SUCCESS:
+        return state.set("getOptionByIdStatus", SUCCESS).set("getOptionById", fromJS(action.result)).set("getOptionByIdError", null);
+      case GET_OPTION_BY_ID_FAILURE:
+        return state.set("getOptionByIdStatus", FAILURE).set("getOptionById", fromJS({})).set("getOptionByIdError", action.error);
+      case CLEAR_DATA_ON_UNMOUNT:
+        return initialState;
+      default:
+        return state;
+    }
+  };
+}
+export {
+  CapVirtualSelectRootReducer as default,
+  initialState
+};

package/CapVirtualSelect/saga.d.ts

@@ -0,0 +1,40 @@
+export declare function actionMatcher({ action, namespace, type }: {
+    action: any;
+    namespace: any;
+    type: any;
+}): boolean;
+export declare function getPaginatedOptions(namespace: any, { listingApiConfig, queryParams, transformOptions }: {
+    listingApiConfig: any;
+    queryParams: any;
+    transformOptions: any;
+}): Generator<import("redux-saga/effects").CallEffect<unknown> | import("redux-saga/effects").PutEffect<{
+    type: string;
+    namespace: any;
+    result: any[];
+    appendOptions: boolean;
+    totalCount: any;
+    selectedValueKey: any;
+    isSearchValueDefined: boolean;
+    transformOptions: any;
+}> | import("redux-saga/effects").PutEffect<{
+    type: string;
+    namespace: any;
+    error: any;
+}>, void, unknown>;
+export declare function getOptionById(namespace: any, { id, getByIdApiConfig, queryParams }: {
+    id: any;
+    getByIdApiConfig: any;
+    queryParams: any;
+}): Generator<import("redux-saga/effects").CallEffect<unknown> | import("redux-saga/effects").PutEffect<{
+    type: string;
+    namespace: any;
+    result: any;
+}> | import("redux-saga/effects").PutEffect<{
+    type: string;
+    namespace: any;
+    error: any;
+}>, void, unknown>;
+export declare function watchGetPaginatedOptions(namespace: any): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export declare function watchGetOptionById(namespace: any): Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>;
+export default function CapVirtualSelectRootSaga(namespace?: string): () => Generator<import("redux-saga/effects").AllEffect<Generator<import("redux-saga/effects").ForkEffect<never>, void, unknown>>, void, unknown>;
+//# sourceMappingURL=saga.d.ts.map

package/CapVirtualSelect/saga.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saga.d.ts","sourceRoot":"","sources":["../../components/CapVirtualSelect/saga.ts"],"names":[],"mappings":"AAUA,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE;;;;CAAA,WAExD;AAGD,wBAAiB,mBAAmB,CAClC,SAAS,KAAA,EACT,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB,EAAE;;;;CAAA;;;;;;;;;;;;;mBA+BpD;AAGD,wBAAiB,aAAa,CAAC,SAAS,KAAA,EAAE,EAAE,EAAE,EAAE,gBAAgB,EAAE,WAAW,EAAE;;;;CAAA;;;;;;;;mBAuB9E;AAGD,wBAAiB,wBAAwB,CAAC,SAAS,KAAA,4EAOlD;AAGD,wBAAiB,kBAAkB,CAAC,SAAS,KAAA,4EAM5C;AAGD,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,SAAS,SAAyB,oJAIlF"}

package/CapVirtualSelect/saga.js

@@ -0,0 +1,91 @@
+import get from "lodash/get";
+import isEmpty from "lodash/isEmpty";
+import values from "lodash/values";
+import { all, takeLatest, call, put } from "redux-saga/effects";
+import { defaultNamespace, GET_PAGINATED_OPTIONS_REQUEST, GET_OPTION_BY_ID_REQUEST, GET_OPTION_BY_ID_SUCCESS, GET_OPTION_BY_ID_FAILURE, GET_PAGINATED_OPTIONS_SUCCESS, GET_PAGINATED_OPTIONS_FAILURE } from "./constants.js";
+const fallbackErrorMessage = "An error ocurred with api!";
+function actionMatcher({ action, namespace, type }) {
+  return (action == null ? void 0 : action.namespace) === namespace && (action == null ? void 0 : action.type) === type;
+}
+function* getPaginatedOptions(namespace, { listingApiConfig, queryParams, transformOptions }) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  try {
+    const response = yield call(listingApiConfig == null ? void 0 : listingApiConfig.method, queryParams);
+    if (get(response, (_a = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _a.successStatus, false)) {
+      yield put({
+        type: GET_PAGINATED_OPTIONS_SUCCESS,
+        namespace,
+        result: values(get(response, (_b = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _b.success, [])),
+        appendOptions: queryParams[(_d = (_c = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _c.page) == null ? void 0 : _d.key] !== ((_f = (_e = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _e.page) == null ? void 0 : _f.value),
+        totalCount: get(response, (_g = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _g.totalCount, 0),
+        selectedValueKey: (_h = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _h.value,
+        isSearchValueDefined: !isEmpty(queryParams[(_j = (_i = listingApiConfig == null ? void 0 : listingApiConfig.apiParamsMapper) == null ? void 0 : _i.search) == null ? void 0 : _j.key]),
+        transformOptions
+      });
+    } else {
+      yield put({
+        type: GET_PAGINATED_OPTIONS_FAILURE,
+        namespace,
+        error: get(response, (_k = listingApiConfig == null ? void 0 : listingApiConfig.payloadPath) == null ? void 0 : _k.error, fallbackErrorMessage)
+      });
+    }
+  } catch (error) {
+    yield put({
+      type: GET_PAGINATED_OPTIONS_FAILURE,
+      namespace,
+      error
+    });
+  }
+}
+function* getOptionById(namespace, { id, getByIdApiConfig, queryParams }) {
+  var _a, _b, _c;
+  try {
+    const response = yield call(getByIdApiConfig == null ? void 0 : getByIdApiConfig.method, id, queryParams);
+    if (get(response, (_a = getByIdApiConfig == null ? void 0 : getByIdApiConfig.payloadPath) == null ? void 0 : _a.successStatus, false)) {
+      yield put({
+        type: GET_OPTION_BY_ID_SUCCESS,
+        namespace,
+        result: get(response, (_b = getByIdApiConfig == null ? void 0 : getByIdApiConfig.payloadPath) == null ? void 0 : _b.success, {})
+      });
+    } else {
+      yield put({
+        type: GET_OPTION_BY_ID_FAILURE,
+        namespace,
+        error: get(response, (_c = getByIdApiConfig == null ? void 0 : getByIdApiConfig.payloadPath) == null ? void 0 : _c.error, fallbackErrorMessage)
+      });
+    }
+  } catch (error) {
+    yield put({
+      type: GET_OPTION_BY_ID_FAILURE,
+      namespace,
+      error
+    });
+  }
+}
+function* watchGetPaginatedOptions(namespace) {
+  yield takeLatest(
+    (action) => actionMatcher({ action, namespace, type: GET_PAGINATED_OPTIONS_REQUEST }),
+    getPaginatedOptions,
+    namespace
+  );
+}
+function* watchGetOptionById(namespace) {
+  yield takeLatest(
+    (action) => actionMatcher({ action, namespace, type: GET_OPTION_BY_ID_REQUEST }),
+    getOptionById,
+    namespace
+  );
+}
+function CapVirtualSelectRootSaga(namespace = defaultNamespace) {
+  return function* CapVirtualSelectSaga() {
+    yield all([watchGetPaginatedOptions(namespace), watchGetOptionById(namespace)]);
+  };
+}
+export {
+  actionMatcher,
+  CapVirtualSelectRootSaga as default,
+  getOptionById,
+  getPaginatedOptions,
+  watchGetOptionById,
+  watchGetPaginatedOptions
+};

package/CapVirtualSelect/selectors.d.ts

@@ -0,0 +1,28 @@
+declare const makeSelectGetPaginatedOptions: () => ((state: import("immutable").Map<never, never>, ownProps: any) => {
+    getPaginatedOptionsStatus: any;
+    getPaginatedOptions: any;
+    getUnTransformedPaginatedOptions: any;
+    getPaginatedOptionsTotalCount: any;
+}) & import("reselect").OutputSelectorFields<(args_0: import("immutable").Map<"getPaginatedOptionsStatus" | "getPaginatedOptions" | "getUnTransformedPaginatedOptions" | "getPaginatedOptionsError" | "getPaginatedOptionsTotalCount" | "getOptionByIdStatus" | "getOptionById" | "getOptionByIdError", any>) => {
+    getPaginatedOptionsStatus: any;
+    getPaginatedOptions: any;
+    getUnTransformedPaginatedOptions: any;
+    getPaginatedOptionsTotalCount: any;
+}, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+declare const makeSelectGetOptionById: () => ((state: import("immutable").Map<never, never>, ownProps: any) => {
+    getOptionByIdStatus: any;
+    getOptionById: any;
+}) & import("reselect").OutputSelectorFields<(args_0: import("immutable").Map<"getPaginatedOptionsStatus" | "getPaginatedOptions" | "getUnTransformedPaginatedOptions" | "getPaginatedOptionsError" | "getPaginatedOptionsTotalCount" | "getOptionByIdStatus" | "getOptionById" | "getOptionByIdError", any>) => {
+    getOptionByIdStatus: any;
+    getOptionById: any;
+}, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export { makeSelectGetPaginatedOptions, makeSelectGetOptionById };
+//# sourceMappingURL=selectors.d.ts.map