"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.CanaryTabs = CanaryTabs;
exports.Tabs = Tabs;
exports.filterChecksByTabSelection = filterChecksByTabSelection;
exports.generateTabs = generateTabs;

var _react = _interopRequireWildcard(require("react"));

var _jsxRuntime = require("react/jsx-runtime");

var _excluded = ["checks", "tabBy", "setTabSelection"],
    _excluded2 = ["tabs", "value", "onClick", "className"];

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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var defaultTabs = {
  all: {
    key: "all",
    value: "all",
    label: "All"
  }
}; // filter checks according to the 'tabBy' and selected tab

function filterChecksByTabSelection(tabBy, selectedTab, checks) {
  if (checks == null || checks && Object.keys(checks).length === 0 && Object.getPrototypeOf(checks) === Object.prototype) {
    return checks;
  }

  var filteredChecks = checks;

  if (selectedTab !== "all") {
    if (tabBy === "namespace") {
      // if filter by namespace, show only selected namespace
      filteredChecks = checks.filter(function (o) {
        return o.namespace === selectedTab;
      });
    } else {
      // filtered by non-boolean labels
      filteredChecks = checks.filter(function (o) {
        return Object.prototype.hasOwnProperty.call(o.labels, tabBy) && o.labels[tabBy] === selectedTab;
      });
    }
  }

  return filteredChecks;
}

function generateTabs(tabBy, checks) {
  if (checks == null) {
    return defaultTabs;
  }

  var tabs = defaultTabs;

  if (tabBy === "namespace") {
    var namespaces = _toConsumableArray(new Set(checks.map(function (o) {
      return o.namespace;
    })));

    tabs = _objectSpread(_objectSpread({}, tabs), namespaces.reduce(function (acc, namespace) {
      return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, namespace, {
        key: namespace,
        value: namespace,
        label: namespace
      }));
    }, {}));
  } else {
    // generate tabs by non boolean label
    var label = tabBy;
    var matchingLabelValues = checks.reduce(function (acc, o) {
      if (o.labels == null) {
        return acc;
      }

      var labelKeys = Object.keys(o.labels);

      if (labelKeys.length > 0 && labelKeys.includes(label)) {
        acc = _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, o.labels[label], null));
      }

      return acc;
    }, {});
    tabs = _objectSpread(_objectSpread({}, tabs), Object.keys(matchingLabelValues).reduce(function (acc, labelValue) {
      return _objectSpread(_objectSpread({}, acc), {}, _defineProperty({}, labelValue, {
        key: labelValue,
        value: labelValue,
        label: labelValue
      }));
    }, {}));
  }

  return tabs;
}

function CanaryTabs(_ref) {
  var checks = _ref.checks,
      tabBy = _ref.tabBy,
      setTabSelection = _ref.setTabSelection,
      rest = _objectWithoutProperties(_ref, _excluded);

  var _useState = (0, _react.useState)(generateTabs(tabBy, checks)),
      _useState2 = _slicedToArray(_useState, 2),
      tabs = _useState2[0],
      setTabs = _useState2[1];

  var _useState3 = (0, _react.useState)(Object.values(tabs)[0].value),
      _useState4 = _slicedToArray(_useState3, 2),
      selectedTab = _useState4[0],
      setSelectedTab = _useState4[1]; // changes in checks and tabBy(dropdown) will generate new tabs


  (0, _react.useEffect)(function () {
    setTabs(generateTabs(tabBy, checks));
  }, [checks, tabBy]); // checking if previously selected tab still exists in newly-generated tabs

  (0, _react.useEffect)(function () {
    // if it doesnt exist, reset to the first tab value
    if (!Object.prototype.hasOwnProperty.call(tabs, selectedTab)) {
      setSelectedTab(Object.values(tabs)[0].value);
    }
  }, [tabs, selectedTab]); // changes in selected tab will trigger setTabSelection callback

  (0, _react.useEffect)(function () {
    setTabSelection(selectedTab);
  }, [selectedTab, setTabSelection]);
  return /*#__PURE__*/(0, _jsxRuntime.jsx)(Tabs, _objectSpread(_objectSpread({}, rest), {}, {
    tabs: Object.values(tabs),
    value: selectedTab,
    onClick: function onClick(tab) {
      return setSelectedTab(tab.value);
    }
  }));
}

function classNames() {
  for (var _len = arguments.length, classes = new Array(_len), _key = 0; _key < _len; _key++) {
    classes[_key] = arguments[_key];
  }

  return classes.filter(Boolean).join(" ");
}

function Tabs(_ref2) {
  var tabs = _ref2.tabs,
      value = _ref2.value,
      _onClick = _ref2.onClick,
      className = _ref2.className,
      rest = _objectWithoutProperties(_ref2, _excluded2);

  return /*#__PURE__*/(0, _jsxRuntime.jsx)("div", _objectSpread(_objectSpread({
    className: "flex flex-wrap border-b border-gray-300 ".concat(className),
    "aria-label": "Tabs"
  }, rest), {}, {
    children: tabs.map(function (tab) {
      return /*#__PURE__*/(0, _jsxRuntime.jsx)("button", {
        type: "button",
        onClick: function onClick() {
          return _onClick(tab);
        },
        style: {
          marginBottom: "-1px",
          borderColor: tab.value === value ? "" : "transparent",
          borderBottomColor: tab.value === value ? "white" : ""
        },
        className: classNames(tab.value === value ? "text-gray-900" : "text-gray-500", "px-4 py-2 font-medium text-sm rounded-t-md border border-gray-300 hover:text-gray-900"),
        children: tab.label
      }, tab.value);
    })
  }));
}