@urbanos/react-discovery-ui 2.1.43

package/lib/components/dataset-dictionary/dataset-dictionary.scss

@@ -0,0 +1,42 @@
+@import '../../styles/variables.scss';
+@import '../../styles/mixins.scss';
+
+dataset-dictionary {
+  .view-link {
+    padding: 1rem;
+    text-align: right;
+
+    .view-text {
+      font-size: 1.2rem;
+    }
+
+    a {
+      @include sub-link();
+    }
+  }
+
+  .dataset-schema-table {
+    color: $almost-black;
+
+    .ReactTable {
+      border-width: 0
+    }
+
+    .table-header {
+      text-align: left;
+      font-weight: 800;
+    }
+
+    .description-cell {
+      white-space: unset;
+    }
+
+    .expander {
+      text-align: center;
+    }
+  }
+
+  .error {
+    color: $error-color
+  }
+}

package/lib/components/dataset-dictionary/dataset-dictionary.test.js

@@ -0,0 +1,286 @@
+import { shallow, mount } from 'enzyme'
+import DatasetDictionary from './dataset-dictionary'
+import CollapsableBox from '../collapsable-box'
+import ReactTable from 'react-table'
+import Tooltip from '../tooltip'
+
+describe('dataset dictionary', () => {
+  const basicSchema = [
+    { name: 'name', type: 'string', description: 'the name' },
+    { name: 'age', type: 'integer', description: 'the age' }
+  ]
+
+  let subject
+
+  describe('with a basic schema', () => {
+    beforeEach(() => {
+      const matchMedia = jest.fn()
+      Object.defineProperty(window, 'matchMedia', {
+        writable: true,
+        value: jest.fn().mockImplementation(query => ({
+          matches: true
+        }))
+      })
+      subject = mount(<DatasetDictionary schema={basicSchema} expanded />)
+    })
+
+    it('has the correct table headers', () => {
+      const table = subject.find('.dataset-schema-table')
+      const headers = table.find('.rt-th')
+
+      expect(headers.length).toBe(4)
+      expect(headers.at(1).text()).toBe('Field')
+      expect(headers.at(2).text()).toBe('Type')
+      expect(headers.at(3).text()).toBe('Description')
+    })
+
+    it('has the correct table values', () => {
+      const table = subject.find('.dataset-schema-table')
+      const cells = table.find('.rt-td')
+
+      const expansionPlaceholder = ''
+      const expectedCellValues = [
+        expansionPlaceholder, 'name', 'string', 'the name',
+        expansionPlaceholder, 'age', 'integer', 'the age'
+      ]
+      expect(cells.length).toBe(expectedCellValues.length)
+      expectCorrectCellValues(expectedCellValues, cells)
+    })
+
+    it('does not have pagination', () => {
+      const table = subject.find(ReactTable)
+      expect(table.props().showPagination).toBe(false)
+    })
+
+    it('has a page size to show the entire schema', () => {
+      const table = subject.find(ReactTable)
+      expect(table.props().defaultPageSize).toBe(Object.keys(basicSchema).length)
+    })
+
+    it('is sortable', () => {
+      const table = subject.find(ReactTable)
+      expect(table.props().sortable).toBe(true)
+    })
+
+    it('has no left margin', () => {
+      const table = subject.find(ReactTable)
+
+      expect(table.props().style.marginLeft).toBeFalsy()
+    })
+  })
+
+  describe('with a schema containing a list type', () => {
+    it('displays the list type appropriately', () => {
+      const schemaWithList = [
+        { name: 'names', type: 'list', description: 'all the names', itemType: 'string' }
+      ]
+
+      subject = mount(<DatasetDictionary schema={schemaWithList} expanded />)
+
+      const table = subject.find('.dataset-schema-table')
+      const cells = table.find('.rt-td')
+
+      const typeIndex = 2
+      expect(cells.at(typeIndex).text()).toBe(`list of ${schemaWithList[0].itemType}`)
+    })
+  })
+
+  describe('with nested map subschemas', () => {
+    const schemaWithMaps = [
+      { name: 'name', type: 'string', description: 'the name' },
+      {
+        name: 'mother',
+        type: 'map',
+        description: 'the mother',
+        subSchema: [
+          { name: 'name', type: 'string', description: 'mother\'s name' },
+          {
+            name: 'children',
+            type: 'list',
+            description: 'the chillins',
+            itemType: 'map',
+            subSchema: [
+              { name: 'age', type: 'integer', description: 'the child\'s age' }
+            ]
+          }
+        ]
+      }
+    ]
+
+    let topLevelTable, topLevelCells
+
+    beforeEach(() => {
+      subject = mount(<DatasetDictionary schema={schemaWithMaps} expanded />)
+      topLevelTable = subject.find('.dataset-schema-table')
+      topLevelCells = topLevelTable.find('.rt-td')
+    })
+
+    it('has the correct table values', () => {
+      const expansionPlaceholder = ''
+      const expansionArrow = '▸'
+      const expectedCellValues = [
+        expansionPlaceholder, 'name', 'string', 'the name',
+        expansionArrow, 'mother', 'map', 'the mother'
+      ]
+      expect(topLevelCells.length).toBe(expectedCellValues.length)
+      expectCorrectCellValues(expectedCellValues, topLevelCells)
+    })
+
+    describe('with the map type expanded', () => {
+      const expanderCellIndex = 4
+
+      let subTable, subTableCells
+
+      beforeEach(() => {
+        topLevelCells.at(expanderCellIndex).simulate('click')
+        topLevelTable = subject.find('.dataset-schema-table')
+
+        subTable = topLevelTable.find('.dataset-schema-table.mother')
+        subTableCells = subTable.find('.rt-td')
+      })
+
+      it('toggles the direction of the arrow', () => {
+        expect(topLevelCells.at(expanderCellIndex).text()).toBe('▾')
+      })
+
+      it('renders a sub table for the map with correct values', () => {
+        expect(subTable.length).toBe(1)
+      })
+
+      it('has the correct values in the sub table', () => {
+        const expansionPlaceholder = ''
+        const expansionArrow = '▸'
+        const expectedCellValues = [
+          expansionPlaceholder, 'name', 'string', 'mother\'s name',
+          expansionArrow, 'children', 'list of map', 'the chillins'
+        ]
+        expect(subTableCells.length).toBe(expectedCellValues.length)
+        expectCorrectCellValues(expectedCellValues, subTableCells)
+      })
+
+      it('indents the sub table', () => {
+        expect(subTable.find(ReactTable).props().style.marginLeft).toBe('35px')
+      })
+
+      it('toggles the direction of the arrow again when collapsed', () => {
+        topLevelCells.at(expanderCellIndex).simulate('click')
+        expect(topLevelCells.at(expanderCellIndex).text()).toBe('▸')
+      })
+
+      describe('and the list of map type expanded', () => {
+        let subSubTable, subSubTableCells
+
+        beforeEach(() => {
+          subTableCells.at(expanderCellIndex).simulate('click')
+          subTable = subject.find('.dataset-schema-table.mother')
+
+          subSubTable = subTable.find('.dataset-schema-table.children')
+          subSubTableCells = subSubTable.find('.rt-td')
+        })
+
+        it('renders another sub table for the list of maps with correct values', () => {
+          expect(subSubTable.length).toBe(1)
+        })
+
+        it('has the correct values in the sub sub table', () => {
+          const expansionPlaceholder = ''
+          const expectedCellValues = [
+            expansionPlaceholder, 'age', 'integer', 'the child\'s age'
+          ]
+          expect(subSubTableCells.length).toBe(expectedCellValues.length)
+          expectCorrectCellValues(expectedCellValues, subSubTableCells)
+        })
+      })
+    })
+  })
+
+  describe('with a map missing its subschema', () => {
+    const schemaWithMaps = [
+      { name: 'name', type: 'string', description: 'the name' },
+      {
+        name: 'mother', type: 'map', description: 'the mother'
+      }
+    ]
+
+    let topLevelTable
+
+    beforeEach(() => {
+      subject = mount(<DatasetDictionary schema={schemaWithMaps} expanded />)
+      topLevelTable = subject.find('.dataset-schema-table')
+      const topLevelCells = topLevelTable.find('.rt-td.rt-expandable')
+      topLevelCells.at(1).simulate('click')
+      topLevelTable = subject.find('.dataset-schema-table')
+    })
+
+    it('displays an informative message', () => {
+      const messageDiv = topLevelTable.find('.error')
+      expect(messageDiv.text()).toBe('Schema information not found. Contact the data curator.')
+    })
+  })
+
+  describe('without a schema', () => {
+    beforeEach(() => {
+      subject = shallow(<DatasetDictionary expanded />)
+    })
+
+    it('renders the collapsable box with an informative message', () => {
+      const collapsableBox = subject.find(CollapsableBox)
+      expect(collapsableBox.length).toBe(1)
+      expect(collapsableBox.props().title).toBe('Data Dictionary Unavailable')
+    })
+
+    it('does not render the table', () => {
+      expect(subject.find('.dataset-schema-table').length).toBe(0)
+    })
+
+    it('does not render the view link', () => {
+      expect(subject.find('.view-link a').length).toBe(0)
+    })
+  })
+
+  describe('with an empty schema', () => {
+    beforeEach(() => {
+      subject = mount(<DatasetDictionary schema={[]} expanded />)
+    })
+
+    it('renders the collapsable box with an informative message', () => {
+      const collapsableBox = subject.find(CollapsableBox)
+      expect(collapsableBox.length).toBe(1)
+      expect(collapsableBox.props().title).toBe('Data Dictionary Unavailable')
+    })
+
+    it('does not render the table', () => {
+      expect(subject.find('.dataset-schema-table').length).toBe(0)
+    })
+
+    it('does not render the view link', () => {
+      expect(subject.find('.view-link a').length).toBe(0)
+    })
+  })
+
+  it('is rendered in an expanded box by default', () => {
+    subject = shallow(<DatasetDictionary schema={basicSchema} />)
+
+    const collapsableBox = subject.find(CollapsableBox)
+    expect(collapsableBox.length).toBe(1)
+    expect(collapsableBox.props().expanded).toBe(true)
+  })
+
+  it('renders a view link', () => {
+    window.DISC_API_URL = 'http://right.here.com'
+    subject = mount(<DatasetDictionary schema={basicSchema} datasetId='all-the-datas' />)
+
+    const link = subject.find('.view-link a')
+    expect(link.props().href).toBe(`${window.DISC_API_URL}/api/v1/dataset/all-the-datas/dictionary`)
+  })
+
+  const expectCorrectCellValues = (expectedCellValues, cells) => {
+    expectedCellValues.forEach((expected, index) => {
+      if (index % 4 == 1) { // handle special rendering for field name tooltip
+        expect(cells.at(index).find(Tooltip).props().text).toBe(expected)
+      } else {
+        expect(cells.at(index).text()).toBe(expected)
+      }
+    })
+  }
+})

package/lib/components/dataset-dictionary/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _datasetDictionary = _interopRequireDefault(require("./dataset-dictionary"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _datasetDictionary.default;

package/lib/components/dataset-list/dataset-list.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _dataCard = _interopRequireDefault(require("../data-card"));
+require("./dataset-list.scss");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var createDatasetCard = function createDatasetCard(dataset) {
+  return /*#__PURE__*/React.createElement(_dataCard.default, {
+    key: dataset.id,
+    dataset: dataset
+  });
+};
+var _default = exports.default = function _default(_ref) {
+  var _ref$datasets = _ref.datasets,
+    datasets = _ref$datasets === void 0 ? [] : _ref$datasets;
+  return /*#__PURE__*/React.createElement("dataset-list", {
+    "data-testid": "dataset-list"
+  }, datasets.map(createDatasetCard) || /*#__PURE__*/React.createElement("div", null));
+};

package/lib/components/dataset-list/dataset-list.scss

@@ -0,0 +1,9 @@
+@import '../../styles/variables.scss';
+@import '../../styles/mixins.scss';
+
+dataset-list {
+  @include custom-element();
+  @include flex-column();
+  justify-content: flex-start;
+  align-items: flex-start;
+}

package/lib/components/dataset-list/dataset-list.test.js

@@ -0,0 +1,16 @@
+import { shallow } from 'enzyme'
+import DatasetList from './dataset-list'
+import DatasetCard from '../data-card'
+import expectedDatasetList from '../../../stubs/dataset-list-stub'
+
+describe('dataset list view', () => {
+  let subject
+
+  beforeEach(() => {
+    subject = shallow(<DatasetList datasets={expectedDatasetList.results} />)
+  })
+
+  it('displays the proper number of datacards based on datasets prop', () => {
+    expect(subject.find(DatasetCard).length).toEqual(expectedDatasetList.results.length)
+  })
+})

package/lib/components/dataset-list/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _datasetList = _interopRequireDefault(require("./dataset-list"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _datasetList.default;

package/lib/components/dataset-metadata/dataset-metadata.js

@@ -0,0 +1,169 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+require("./dataset-metadata.scss");
+var _reactTable = _interopRequireDefault(require("react-table"));
+require("react-table/react-table.css");
+var _collapsableBox = _interopRequireDefault(require("../../components/collapsable-box"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var _default = exports.default = /*#__PURE__*/function (_Component) {
+  function _default() {
+    _classCallCheck(this, _default);
+    return _callSuper(this, _default, arguments);
+  }
+  _inherits(_default, _Component);
+  return _createClass(_default, [{
+    key: "render",
+    value: function render() {
+      var dataset = this.props.dataset;
+      if (!this.props.dataset) {
+        return /*#__PURE__*/_react.default.createElement("div", null);
+      }
+      var referenceUrls = dataset.referenceUrls || [];
+      var data = [{
+        Field: 'Maintainer',
+        Value: mailto(dataset.contactEmail, dataset.contactName)
+      }, {
+        Field: 'Last Updated',
+        Value: dataset.modified
+      }, {
+        Field: 'Data Last Ingested',
+        Value: dataset.lastUpdatedDate
+      }, {
+        Field: 'Rights',
+        Value: dataset.rights
+      }, {
+        Field: 'Spatial',
+        Value: dataset.spatial
+      }, {
+        Field: 'Temporal',
+        Value: dataset.temporal
+      }, {
+        Field: 'Release Date',
+        Value: dataset.issuedDate
+      }, {
+        Field: 'Frequency',
+        Value: dataset.publishFrequency
+      }, {
+        Field: 'Data Dictionary URL',
+        Value: /*#__PURE__*/_react.default.createElement("a", {
+          role: "link",
+          href: dataset.describedByUrl,
+          target: "_blank"
+        }, dataset.describedByUrl)
+      }, {
+        Field: 'Data Dictionary Type',
+        Value: dataset.describedByMimeType
+      }, {
+        Field: 'Collection',
+        Value: dataset.parentDataset
+      }, {
+        Field: 'Language',
+        Value: dataset.language
+      }, {
+        Field: 'Homepage URL',
+        Value: /*#__PURE__*/_react.default.createElement("a", {
+          role: "link",
+          href: dataset.homepage,
+          target: "_blank"
+        }, dataset.homepage)
+      }, {
+        Field: 'Related Documents',
+        Value: referenceUrls.map(function (url) {
+          return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("a", {
+            role: "link",
+            href: url,
+            target: "_blank"
+          }, url));
+        })
+      }, {
+        Field: 'Source URL',
+        Value: /*#__PURE__*/_react.default.createElement("a", {
+          role: "link",
+          href: dataset.sourceUrl,
+          target: "_blank"
+        }, dataset.sourceUrl)
+      }, {
+        Field: 'Source Type',
+        Value: dataset.sourceType
+      }, {
+        Field: 'License',
+        Value: /*#__PURE__*/_react.default.createElement("a", {
+          role: "link",
+          href: dataset.license,
+          target: "_blank"
+        }, dataset.license)
+      }, {
+        Field: 'Category',
+        Value: dataset.catagories
+      }, {
+        Field: 'Count - Downloads',
+        Value: dataset.downloads
+      }, {
+        Field: 'Count - API Queries',
+        Value: dataset.queries
+      }, {
+        Field: 'Access Level',
+        Value: dataset.accessLevel
+      }, {
+        Field: 'Table Name',
+        Value: dataset.systemName
+      }];
+      var columns = [{
+        Header: 'Field',
+        accessor: 'Field',
+        headerClassName: 'table-header',
+        width: 160
+      }, {
+        Header: 'Value',
+        accessor: 'Value',
+        headerClassName: 'table-header'
+      }];
+      return /*#__PURE__*/_react.default.createElement("dataset-metadata", {
+        class: "dataset-metadata"
+      }, /*#__PURE__*/_react.default.createElement(_collapsableBox.default, {
+        title: "Additional Information",
+        expanded: true
+      }, /*#__PURE__*/_react.default.createElement(_reactTable.default, {
+        data: data,
+        columns: columns,
+        defaultPageSize: data.length,
+        className: "-striped -highlight",
+        showPagination: false,
+        sortable: true,
+        defaultSorted: [{
+          id: 'Field',
+          desc: false
+        }]
+      })));
+    }
+  }]);
+}(_react.Component);
+function mailto(email, name) {
+  if (email) {
+    return /*#__PURE__*/_react.default.createElement("a", {
+      role: "link",
+      href: 'mailto:' + email
+    }, name);
+  } else {
+    return /*#__PURE__*/_react.default.createElement("span", null, name);
+  }
+}

package/lib/components/dataset-metadata/dataset-metadata.scss

@@ -0,0 +1,34 @@
+@import '../../styles/variables.scss';
+@import '../../styles/mixins.scss';
+
+dataset-metadata {
+
+  home-banner {
+    display:none !important;
+  }
+  home-banner .banner-background {
+    display:none !important;
+  }
+  .header-container {
+    display: flex;
+    justify-content: space-between;
+  }
+
+  .header-text-items {
+    margin: 1rem;
+  }
+
+  .metadata-header {
+    @include header();
+  }
+
+  .table-header {
+    background-color: $header-grey;
+    text-align: left;
+    font-weight: 800;
+  }
+
+  a {
+    @include sub-link();
+  }
+}

package/lib/components/dataset-metadata/dataset-metadata.test.js

@@ -0,0 +1,24 @@
+import { shallow } from 'enzyme'
+import DatasetMetadata from './dataset-metadata'
+
+describe('additional info element', () => {
+  test('card to render text based on props', () => {
+    const subject = shallow(<DatasetMetadata dataset={{ spatial: 'Ohio' }} />)
+    const table = subject.find('ReactTable')
+    expect(table.prop('data')[4]).toEqual({ Field: 'Spatial', Value: 'Ohio' })
+  })
+
+  test('card renders mailto link correctly', () => {
+    const subject = shallow(<DatasetMetadata dataset={{ contactName: 'John', contactEmail: 'john@smith.com' }} />)
+    const actual = JSON.stringify(subject.find('ReactTable').prop('data')[0])
+    const expected = JSON.stringify({ Field: 'Maintainer', Value: <a role="link" href='mailto:john@smith.com'>John</a> })
+    expect(actual).toEqual(expected)
+  })
+
+  test('referenceUrls renders correctly', () => {
+    const subject = shallow(<DatasetMetadata dataset={{ referenceUrls: ['https://www.google.com', 'https://www.facebook.com'] }} />)
+    const actual = JSON.stringify(subject.find('ReactTable').prop('data')[13])
+    const expected = JSON.stringify({ Field: 'Related Documents', Value: [<div><a role="link" href='https://www.google.com' target='_blank'>https://www.google.com</a></div>, <div><a role="link" href='https://www.facebook.com' target='_blank'>https://www.facebook.com</a></div>] })
+    expect(actual).toEqual(expected)
+  })
+})

package/lib/components/dataset-metadata/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _datasetMetadata = _interopRequireDefault(require("./dataset-metadata"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _datasetMetadata.default;

package/lib/components/dataset-preview/connector.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactRedux = require("react-redux");
+var _datasetPreview = _interopRequireDefault(require("./dataset-preview"));
+var _actions = require("../../store/actions");
+var _selectors = require("../../store/selectors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var mapStateToProps = function mapStateToProps(state, _ref) {
+  var format = _ref.format;
+  return {
+    datasetPreview: (0, _selectors.getDataSetPreview)(state, format),
+    previewLoading: state.presentation.previewLoading
+  };
+};
+var mapDispatchToProps = function mapDispatchToProps(dispatch) {
+  return {
+    retrieveDatasetPreview: function retrieveDatasetPreview(datasetId) {
+      return dispatch((0, _actions.retrieveDatasetPreview)(datasetId));
+    }
+  };
+};
+var _default = exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(_datasetPreview.default);