@pingux/astro 2.25.0-alpha.0 → 2.25.0-alpha.2

package/lib/cjs/recipes/DataVisualization.stories.js

@@ -0,0 +1,416 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs3/helpers/typeof");
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+var _Symbol = require("@babel/runtime-corejs3/core-js-stable/symbol");
+var _Object$create = require("@babel/runtime-corejs3/core-js-stable/object/create");
+var _Object$getPrototypeOf = require("@babel/runtime-corejs3/core-js-stable/object/get-prototype-of");
+var _forEachInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/for-each");
+var _Object$setPrototypeOf = require("@babel/runtime-corejs3/core-js-stable/object/set-prototype-of");
+var _Promise = require("@babel/runtime-corejs3/core-js-stable/promise");
+var _reverseInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/reverse");
+var _sliceInstanceProperty = require("@babel/runtime-corejs3/core-js-stable/instance/slice");
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.Default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/extends"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/slicedToArray"));
+var _includes = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/includes"));
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactStately = require("react-stately");
+var _ArrowCollapseRightIcon = _interopRequireDefault(require("@pingux/mdi-react/ArrowCollapseRightIcon"));
+var _EyeOutlineIcon = _interopRequireDefault(require("@pingux/mdi-react/EyeOutlineIcon"));
+var _TrayArrowDownIcon = _interopRequireDefault(require("@pingux/mdi-react/TrayArrowDownIcon"));
+var _index = require("../index");
+var _images = require("../utils/devUtils/constants/images");
+var _react2 = require("@emotion/react");
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = _Object$defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof _Symbol ? _Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return _Object$defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = _Object$create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = _Object$getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = _Object$create(IteratorPrototype); function defineIteratorMethods(prototype) { var _context6; _forEachInstanceProperty(_context6 = ["next", "throw", "return"]).call(_context6, function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], _forEachInstanceProperty(tryLocsList).call(tryLocsList, pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return _Object$setPrototypeOf ? _Object$setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = _Object$create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = _Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return _reverseInstanceProperty(keys).call(keys), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { var _context7; if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, _forEachInstanceProperty(_context7 = this.tryEntries).call(_context7, resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+_sliceInstanceProperty(name).call(name, 1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, "catch": function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+var _default = {
+  title: 'Recipes/Data Visualization with Filtering'
+};
+exports["default"] = _default;
+var columns = [{
+  name: 'Country',
+  key: 'country'
+}, {
+  name: 'Population',
+  key: 'population'
+}, {
+  name: 'Continent',
+  key: 'continent'
+}];
+var numberRanges = [{
+  label: '0-100',
+  numberLow: 0,
+  numberHigh: 100000000
+}, {
+  label: '100+',
+  numberLow: 100000001,
+  numberHigh: 1000000000000
+}];
+var rows = [{
+  id: 1,
+  country: 'USA',
+  population: 320000000,
+  continent: 'North America'
+}, {
+  id: 2,
+  country: 'Canada',
+  population: 37000000,
+  continent: 'North America'
+}, {
+  id: 3,
+  country: 'China',
+  population: 1398000000,
+  continent: 'Asia'
+}, {
+  id: 4,
+  country: 'France',
+  population: 67000000,
+  continent: 'Europe'
+}, {
+  id: 5,
+  country: 'Mexico',
+  population: 126000000,
+  continent: 'South America'
+}, {
+  id: 6,
+  country: 'Ethiopia',
+  population: 120000000,
+  continent: 'Africa'
+}, {
+  id: 7,
+  country: 'Austria',
+  population: 25000000,
+  continent: 'Oceania'
+}];
+var ControlledCheckBoxGroup = function ControlledCheckBoxGroup(props) {
+  var value = props.value,
+    object = props.object,
+    onChangeCallback = props.onChangeCallback,
+    state = props.state;
+  var onSelect = function onSelect() {
+    if ((0, _includes["default"])(state).call(state, object)) {
+      var _context;
+      var newarr = (0, _filter["default"])(state).call(state, function (pop) {
+        return pop !== object;
+      });
+      onChangeCallback((0, _concat["default"])(_context = []).call(_context, newarr));
+    } else {
+      var _context2;
+      onChangeCallback((0, _concat["default"])(_context2 = []).call(_context2, state, [object]));
+    }
+  };
+  return (0, _react2.jsx)(_index.CheckboxField, {
+    isSelected: (0, _includes["default"])(state).call(state, object),
+    onChange: function onChange() {
+      return onSelect();
+    },
+    label: value,
+    key: value,
+    paddingBottom: "5px"
+  });
+};
+var MemoizedCheckbox = /*#__PURE__*/_react["default"].memo(ControlledCheckBoxGroup);
+var ControlledSelectField = function ControlledSelectField(props) {
+  var setSelectedContinent = props.setSelectedContinent,
+    selectedContinent = props.selectedContinent;
+  var handleSelectionChange = function handleSelectionChange(key) {
+    return setSelectedContinent(key);
+  };
+  return (0, _react2.jsx)(_index.SelectField, {
+    selectedKey: selectedContinent,
+    onSelectionChange: handleSelectionChange,
+    label: "Filter by Continent",
+    mb: "lg",
+    key: "selectfield"
+  }, (0, _react2.jsx)(_index.Item, {
+    key: "North America"
+  }, "North America"), (0, _react2.jsx)(_index.Item, {
+    key: "South America"
+  }, "South America"), (0, _react2.jsx)(_index.Item, {
+    key: "Africa"
+  }, "Africa"), (0, _react2.jsx)(_index.Item, {
+    key: "Oceania"
+  }, "Oceania"), (0, _react2.jsx)(_index.Item, {
+    key: "Europe"
+  }, "Europe"), (0, _react2.jsx)(_index.Item, {
+    key: "Asia"
+  }, "Asia"), (0, _react2.jsx)(_index.Item, {
+    key: "All Continents"
+  }, "All Continents"));
+};
+var ControlledRadioGroup = function ControlledRadioGroup(props) {
+  var state = props.state,
+    callback = props.callback;
+  return (0, _react2.jsx)(_index.RadioGroupField, {
+    label: "Filter by Continent",
+    value: state,
+    onChange: function onChange(newValue) {
+      return callback(newValue);
+    },
+    key: "radioParent"
+  }, (0, _react2.jsx)(_index.RadioField, {
+    value: "North America",
+    label: "North America",
+    key: "North America",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "South America",
+    label: "South America",
+    key: "South America",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "Africa",
+    label: "Africa",
+    key: "Africa",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "Oceania",
+    label: "Oceania",
+    key: "Oceania",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "Europe",
+    label: "Europe",
+    key: "Europe",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "Asia",
+    label: "Asia",
+    key: "Asia",
+    pb: "5px"
+  }), (0, _react2.jsx)(_index.RadioField, {
+    value: "All Continents",
+    label: "All Continents",
+    key: "All Continents",
+    pb: "5px"
+  }));
+};
+var SideBar = function SideBar(props) {
+  var selectedPopulationRanges = props.selectedPopulationRanges,
+    setSelectedPopulationRanges = props.setSelectedPopulationRanges,
+    selectedContinent = props.selectedContinent,
+    setSelectedContinent = props.setSelectedContinent;
+  return (0, _react2.jsx)(_index.Box, {
+    sx: {
+      minWidth: '194px',
+      overflowY: 'hidden',
+      paddingLeft: '2px'
+    },
+    isRow: true,
+    key: "sidebarParent"
+  }, (0, _react2.jsx)(_index.Box, {
+    sx: {
+      width: '174px'
+    },
+    key: "filterParent"
+  }, (0, _react2.jsx)(ControlledSelectField, {
+    key: "controlled selectfield",
+    setSelectedContinent: setSelectedContinent,
+    selectedContinent: selectedContinent
+  }), (0, _react2.jsx)(ControlledRadioGroup, {
+    key: "radioGroup",
+    state: selectedContinent,
+    callback: setSelectedContinent
+  }), (0, _react2.jsx)(_index.Text, {
+    mt: "lg",
+    key: "populationRange",
+    variant: "label"
+  }, "Population Range"), (0, _map["default"])(numberRanges).call(numberRanges, function (num) {
+    return (0, _react2.jsx)(MemoizedCheckbox, {
+      value: num.label,
+      object: num,
+      key: num.label,
+      onChangeCallback: setSelectedPopulationRanges,
+      state: selectedPopulationRanges
+    });
+  })), (0, _react2.jsx)(_index.Separator, {
+    key: "separator",
+    orientation: "vertical",
+    sx: {
+      '&.is-vertical': {
+        mx: 'md',
+        my: 0
+      }
+    }
+  }));
+};
+var Default = function Default(args) {
+  var _useState = (0, _react.useState)('All Continents'),
+    _useState2 = (0, _slicedToArray2["default"])(_useState, 2),
+    selectedContinent = _useState2[0],
+    setSelectedContinent = _useState2[1];
+  var _useState3 = (0, _react.useState)([]),
+    _useState4 = (0, _slicedToArray2["default"])(_useState3, 2),
+    selectedPopulationRanges = _useState4[0],
+    setSelectedPopulationRanges = _useState4[1];
+  var _useState5 = (0, _react.useState)(''),
+    _useState6 = (0, _slicedToArray2["default"])(_useState5, 2),
+    filterText = _useState6[0],
+    setFilterText = _useState6[1];
+  var list = (0, _reactStately.useAsyncList)({
+    load: function load() {
+      return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", {
+                items: rows
+              });
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee);
+      }))();
+    }
+  });
+  var filteredItems = (0, _react.useMemo)(function () {
+    var _context4;
+    return (0, _filter["default"])(_context4 = list.items).call(_context4, function (item) {
+      var _context5;
+      if (!(0, _includes["default"])(_context5 = item.country).call(_context5, filterText)) {
+        return false;
+      }
+      if (selectedContinent !== 'All Continents' && selectedContinent !== item.continent) {
+        return false;
+      }
+      var min = Math.min.apply(Math, (0, _map["default"])(selectedPopulationRanges).call(selectedPopulationRanges, function (range) {
+        return range.numberLow;
+      }));
+      var max = Math.max.apply(Math, (0, _map["default"])(selectedPopulationRanges).call(selectedPopulationRanges, function (range) {
+        return range.numberHigh;
+      }));
+      if (selectedPopulationRanges.length !== 0) {
+        if (item.population > min && item.population < max) {
+          return true;
+        }
+        return false;
+      }
+      return true;
+    });
+  }, [list.items, filterText, selectedContinent, selectedPopulationRanges]);
+  var onChange = function onChange(value) {
+    setFilterText(value);
+  };
+  var CustomButton = function CustomButton(_ref) {
+    var icon = _ref.icon,
+      label = _ref.label,
+      iconTitle = _ref.iconTitle;
+    return (0, _react2.jsx)(_index.Button, {
+      variant: "exampleText",
+      ml: "25px",
+      pr: "0px",
+      pl: "0px"
+    }, (0, _react2.jsx)(_index.Box, {
+      isRow: true,
+      alignItems: "center"
+    }, (0, _react2.jsx)(_index.Icon, {
+      icon: icon,
+      mr: "sm",
+      color: "active",
+      size: 25,
+      title: {
+        name: iconTitle
+      }
+    }), (0, _react2.jsx)(_index.Text, {
+      sx: {
+        fontSize: 'md',
+        fontWeight: 0,
+        color: 'active'
+      }
+    }, label)));
+  };
+  var CustomDataTable = function CustomDataTable() {
+    return (0, _react2.jsx)(_index.DataTable, (0, _extends2["default"])({}, args, {
+      "aria-label": "Static table",
+      height: "100%"
+    }), (0, _react2.jsx)(_index.DataTableHeader, {
+      columns: columns
+    }, function (column) {
+      return (0, _react2.jsx)(_index.DataTableColumn, {
+        align: "center"
+      }, column.name);
+    }), (0, _react2.jsx)(_index.DataTableBody, {
+      items: filteredItems
+    }, function (item) {
+      return (0, _react2.jsx)(_index.DataTableRow, null, function (columnKey) {
+        return (0, _react2.jsx)(_index.DataTableCell, null, item[columnKey]);
+      });
+    }));
+  };
+  return (0, _react2.jsx)(_index.Box, {
+    isRow: true
+  }, (0, _react2.jsx)(SideBar, {
+    key: "sidebar",
+    setSelectedPopulationRanges: setSelectedPopulationRanges,
+    selectedPopulationRanges: selectedPopulationRanges,
+    selectedContinent: selectedContinent,
+    setSelectedContinent: setSelectedContinent
+  }), (0, _react2.jsx)(_index.Box, {
+    sx: {
+      display: 'block',
+      margin: 'md',
+      minHeight: '317px',
+      minWidth: '916px',
+      width: '916px'
+    }
+  }, (0, _react2.jsx)(_index.Box, null, (0, _react2.jsx)(_index.Image, {
+    alt: "placeholder graph",
+    src: _images.placeholder
+  })), (0, _react2.jsx)(_index.Box, {
+    maxWidth: "916px"
+  }, (0, _react2.jsx)(_index.Box, {
+    isRow: true,
+    sx: {
+      pt: 'lg',
+      pb: 'lg'
+    }
+  }, (0, _react2.jsx)(_index.SearchField, {
+    onChange: onChange,
+    value: filterText,
+    "aria-label": "filter results",
+    containerProps: {
+      sx: {
+        width: '400px'
+      }
+    },
+    iconProps: {
+      size: 20
+    }
+  }), (0, _react2.jsx)(_index.Box, {
+    isRow: true,
+    sx: {
+      ml: 'auto',
+      mr: '0px',
+      alignItems: 'center',
+      justifyContent: 'center'
+    }
+  }, (0, _react2.jsx)(CustomButton, {
+    label: "Download Report",
+    icon: _TrayArrowDownIcon["default"],
+    iconTitle: "Tray Arrow Down Icon"
+  }), (0, _react2.jsx)(CustomButton, {
+    label: "Modify Columns",
+    icon: _EyeOutlineIcon["default"],
+    iconTitle: "Eye Outline Icon"
+  }), (0, _react2.jsx)(CustomButton, {
+    label: "Run Report",
+    icon: _ArrowCollapseRightIcon["default"],
+    iconTitle: "Arrow Collapse Right Icon"
+  }))), (0, _react2.jsx)(_index.Box, null, (0, _react2.jsx)(CustomDataTable, {
+    key: "customDataTable"
+  })))));
+};
+exports.Default = Default;

package/lib/cjs/utils/devUtils/constants/images.js

@@ -4,8 +4,10 @@ var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/obje
 _Object$defineProperty(exports, "__esModule", {
   value: true
 });
-exports.pingImg = exports.chiefIdentityChampions = void 0;
+exports.placeholder = exports.pingImg = exports.chiefIdentityChampions = void 0;
 var pingImg = 'data:image/png;base64,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';
 exports.pingImg = pingImg;
+var placeholder = 'data:image/png;base64,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';
+exports.placeholder = placeholder;
 var chiefIdentityChampions = 'https://images.pingidentity.com/image/upload/f_auto,q_auto,w_auto,c_scale/ping_dam/content/dam/ping-6-2-assets/images/company/our-company/chief-identity-champions.png';
 exports.chiefIdentityChampions = chiefIdentityChampions;

package/lib/components/Button/Buttons.styles.js

@@ -249,6 +249,13 @@ var headerBar = _objectSpread(_objectSpread({}, base), {}, {
   }),
   '&.is-focused': _objectSpread({}, defaultFocus)
 });
+var exampleText = _objectSpread(_objectSpread({}, base), {}, {
+  '&.is-hovered': {
+    textDecoration: 'underline'
+  },
+  background: 'none',
+  '&.is-focused': _objectSpread({}, defaultFocus)
+});
 export default {
   critical: critical,
   "default": _objectSpread(_objectSpread({}, base), {}, {
@@ -268,6 +275,7 @@ export default {
   quiet: quiet,
   success: success,
   colorBlock: colorBlock,
+  exampleText: exampleText,
   withIcon: withIcon,
   inlineWithIcon: inlineWithIcon,
   inlinePrimaryWithIcon: inlinePrimaryWithIcon