How to use the reselect.createStructuredSelector function in reselect

);
  }
}

ProjectPage.propTypes = {
  projects: PropTypes.array,
  getProjectData: PropTypes.func,
};

export function mapDispatchToProps(dispatch) {
  return {
    getProjectData: () => dispatch(loadProjectData()),
  };
}

const mapStateToProps = createStructuredSelector({
  // repos: makeSelectRepos(),
  // username: makeSelectUsername(),
  loading: makeSelectLoading(),
  projects: makeSelectProjects(),
});

const withConnect = connect(
  mapStateToProps,
  mapDispatchToProps,
);

const withReducer = injectReducer({ key: 'project', reducer });
const withSaga = injectSaga({ key: 'project', saga });

export default compose(
  withReducer,

<button>
              Save
              </button> */}
          
          
        
      
    );
  }
}

const mapStateToProps = createStructuredSelector({
  one: makeSelectOne(),
  loading: makeSelectLoading(),
});

const withConnect = connect(
  mapStateToProps,
  { ...mapDispatchToProps, push },
);

const withReducer = injectReducer({ key: 'blogCommentManagePage', reducer });
const withSaga = injectSaga({ key: 'blogCommentManagePage', saga });

const styles = theme =&gt; ({
  backbtn: {
    padding: 0,
    height: '40px',

} else {
      return }
        visualization={lists.size > 0 ?  : }
      />
    }
  }
}

const statusSelector = createAggregatedPromiseStatusSelector([
  graphStatusSelector,
  searchableLensStatusSelector,
  getConfigurationStatusSelector ]);

const selector = createStructuredSelector({
  graph: graphSelector,
  searchableLens: searchableLensSelector,
  lists: listsSelector,
  publishSettings: publishSettingsSelector,
  status: statusSelector
});

export default connect(selector)(addBodyPadding(Application));

export function mapDispatchToProps (dispatch) {
  return {
    onLoadAdminAllNamespaces: (resolve) => dispatch(loadAdminAllNamespaces(resolve)),
    onLoadUserNamespaces: (projectId, resolve) => dispatch(loadUserNamespaces(projectId, resolve)),
    onLoadSelectNamespaces: (projectId, resolve) => dispatch(loadSelectNamespaces(projectId, resolve)),
    onAddNamespace: (value, resolve) => dispatch(addNamespace(value, resolve)),
    onEditNamespace: (value, resolve) => dispatch(editNamespace(value, resolve)),
    onLoadDatabasesInstance: (value, resolve) => dispatch(loadDatabasesInstance(value, resolve)),
    onLoadNamespaceDatabase: (value, resolve) => dispatch(loadNamespaceDatabase(value, resolve)),
    onLoadTableNameExist: (value, resolve, reject) => dispatch(loadTableNameExist(value, resolve, reject)),
    onLoadSingleNamespace: (namespaceId, resolve) => dispatch(loadSingleNamespace(namespaceId, resolve)),
    onLoadSingleInstance: (namespaceId, resolve) => dispatch(loadSingleInstance(namespaceId, resolve))
  }
}

const mapStateToProps = createStructuredSelector({
  namespaces: selectNamespaces(),
  error: selectError(),
  modalLoading: selectModalLoading(),
  tableNameExited: selectTableNameExited(),
  dbUrlValue: selectDbUrlValue()
})

export default connect(mapStateToProps, mapDispatchToProps)(Namespace)

"bottom-center",
    "bottom-right"
  ]),
  order: PropTypes.oneOf(["top-down", "down-up"]),
  pauseOnHover: PropTypes.bool,
  stack: PropTypes.array
};

Notifications.defaultProps = {
  position: "top-right",
  order: "top-down",
  pauseOnHover: false,
  stack: []
};

const mapStateToProps = createStructuredSelector({
  stack: stackSelector
});

const mapDispatchToProps = {
  destroy
};

export default connect(
  mapStateToProps,
  mapDispatchToProps
)(Notifications);

)
  }
}

const mapStateToProps = createStructuredSelector({
  value: getFile,
})

export default connect(
  mapStateToProps,
  { onChange: editFile },
)(FileEditor)

const Wrapper = styled.div`
  background: ${p => p.theme.editorColours.resultBackground};
  position: relative;
  .variable-editor {
    height: 100% !important;
  }
  .CodeMirror {
    background: none !important;

onModalOk={this.onModalOk}
            deleteProject={this.deleteProject}
            currentProject={currentProject}
            onCancel={this.hideProjectForm}
            onCheckUniqueName={this.checkUniqueName}
            showEditProjectForm={this.showProjectForm('transfer')}
            wrappedComponentRef={this.refHandlers.ProjectEditForm}
          />
        
      
    )
  }
}


const mapStateToProps = createStructuredSelector({
  vizs: makeSelectVizs(),
  starUserList: makeSelectStarUserList(),
  loginUser: makeSelectLoginUser(),
  projectDetail: makeSelectCurrentOrganizationProject(),
  organizations: makeSelectOrganizations(),
  currentOrganization: makeSelectCurrentOrganizations(),
  currentOrganizationProjects: makeSelectCurrentOrganizationProjects(),
  currentOrganizationProjectsDetail: makeSelectCurrentOrganizationProjectsDetail(),
  currentOrganizationMembers: makeSelectCurrentOrganizationMembers(),
  collectProjects: makeSelectCollectProjects()
})

export function mapDispatchToProps (dispatch) {
  return {
    onLoadVizs: (pid) => dispatch(loadVizs(pid)),
    onSetCurrentProject: (option) => dispatch(setCurrentProject(option)),

) : (
        Your cart is empty
      )}
    
     {
        history.push('/checkout');
        dispatch(toggleCartHidden());
      }}
    >
      GO TO CHECKOUT
    
  
);

const mapStateToProps = createStructuredSelector({
  cartItems: selectCartItems
});

export default withRouter(connect(mapStateToProps)(CartDropdown));

);
  }
}

SimpleSnackbar.defaultProps = {};

SimpleSnackbar.propTypes = {
  snackbar: PropTypes.object.isRequired,
  message: PropTypes.string.isRequired,
  close: PropTypes.func.isRequired,
  className: PropTypes.string,
  classes: PropTypes.object,
};

const mapStateToProps = createStructuredSelector({
  snackbar: selectOpen(),
  message: selectMessage(),
});

const mapDispatchToProps = dispatch => ({
  close: () => dispatch(hideSnackbar()),
});

const withConnect = connect(
  mapStateToProps,
  mapDispatchToProps,
);

export default compose(
  withStyles(styles1),
  withConnect,