@radui/ui 0.0.4 → 0.0.6

package/dist/components/Tabs.js

@@ -1,19 +1,33 @@
 'use client';
 import React, { useState } from 'react';
 
-const RAD_UI_CLASS_PREFIX = 'rad-ui';
-const customClassSwitcher = function (customRootClass) {
-  let componentName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-  // applies a custom root class the user provides, else applies the default rad-ui classes to the component
-  // rad ui's classes are based on this logic
-
-  // add dashes between capitalized words
-  const componentClassName = componentName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
-  if (customRootClass) return customRootClass;
-  if (componentName) return `${RAD_UI_CLASS_PREFIX}-${componentClassName}`;
-  return '';
-};
-
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -28,49 +42,114 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+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 _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 _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+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 _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;
+}
+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.");
+}
 
-const COMPONENT_NAME$3 = 'TabTrigger';
-const TabTrigger = _ref => {
-  let {
-    tab,
-    setActiveTab,
-    activeTab,
-    className = '',
-    customRootClass,
-    ...props
-  } = _ref;
-  const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$3);
-  const isActive = activeTab === tab.value;
-  const handleClick = tab => {
+var RAD_UI_CLASS_PREFIX = 'rad-ui';
+var customClassSwitcher = function customClassSwitcher(customRootClass) {
+  var componentName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  // applies a custom root class the user provides, else applies the default rad-ui classes to the component
+  // rad ui's classes are based on this logic
+
+  // add dashes between capitalized words
+  var componentClassName = componentName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+  if (customRootClass) return customRootClass;
+  if (componentName) return "".concat(RAD_UI_CLASS_PREFIX, "-").concat(componentClassName);
+  return '';
+};
+
+var _excluded$2 = ["tab", "setActiveTab", "activeTab", "className", "customRootClass"];
+var COMPONENT_NAME$3 = 'TabTrigger';
+var TabTrigger = function TabTrigger(_ref) {
+  var tab = _ref.tab,
+    setActiveTab = _ref.setActiveTab,
+    activeTab = _ref.activeTab,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    customRootClass = _ref.customRootClass,
+    props = _objectWithoutProperties(_ref, _excluded$2);
+  var rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$3);
+  var isActive = activeTab === tab.value;
+  var handleClick = function handleClick(tab) {
     setActiveTab(tab.value);
   };
   return /*#__PURE__*/React.createElement("button", _extends({
     role: "tab",
-    className: `${rootClass} ${isActive ? 'active' : ''} ${className}`
+    className: "".concat(rootClass, " ").concat(isActive ? 'active' : '', " ").concat(className)
   }, props, {
-    onClick: () => handleClick(tab)
+    onClick: function onClick() {
+      return handleClick(tab);
+    }
   }), /*#__PURE__*/React.createElement("span", {
-    className: `${rootClass}-inner`
+    className: "".concat(rootClass, "-inner")
   }, tab.label));
 };
 TabTrigger.displayName = 'TabTrigger';
 
-const COMPONENT_NAME$2 = 'TabList';
-const TabList = _ref => {
-  let {
-    tabs = [],
-    className = '',
-    setActiveTab,
-    activeTab,
-    customRootClass = ''
-  } = _ref;
-  const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$2);
+var COMPONENT_NAME$2 = 'TabList';
+var TabList = function TabList(_ref) {
+  var _ref$tabs = _ref.tabs,
+    tabs = _ref$tabs === void 0 ? [] : _ref$tabs,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    setActiveTab = _ref.setActiveTab,
+    activeTab = _ref.activeTab,
+    _ref$customRootClass = _ref.customRootClass,
+    customRootClass = _ref$customRootClass === void 0 ? '' : _ref$customRootClass;
+  var rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$2);
   return /*#__PURE__*/React.createElement("div", {
     role: "tablist",
     "aria-orientation": "horizontal",
     "aria-label": "todo",
-    className: `${rootClass} ${className}`
-  }, tabs.map((tab, index) => {
+    className: "".concat(rootClass, " ").concat(className)
+  }, tabs.map(function (tab, index) {
     return /*#__PURE__*/React.createElement(TabTrigger, {
       activeTab: activeTab,
       setActiveTab: setActiveTab,
@@ -82,18 +161,19 @@ const TabList = _ref => {
 };
 TabList.displayName = COMPONENT_NAME$2;
 
-const COMPONENT_NAME$1 = 'TabContent';
-const TabContent = _ref => {
-  let {
-    tabs = [],
-    activeTab,
-    className = '',
-    customRootClass = ''
-  } = _ref;
-  const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$1);
+var COMPONENT_NAME$1 = 'TabContent';
+var TabContent = function TabContent(_ref) {
+  var _ref$tabs = _ref.tabs,
+    tabs = _ref$tabs === void 0 ? [] : _ref$tabs,
+    activeTab = _ref.activeTab,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    _ref$customRootClass = _ref.customRootClass,
+    customRootClass = _ref$customRootClass === void 0 ? '' : _ref$customRootClass;
+  var rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME$1);
   return /*#__PURE__*/React.createElement("div", {
-    className: `${rootClass} ${className}`
-  }, tabs.map((tab, index) => {
+    className: "".concat(rootClass, " ").concat(className)
+  }, tabs.map(function (tab, index) {
     if (tab.value === activeTab) {
       return /*#__PURE__*/React.createElement("div", {
         key: index
@@ -104,32 +184,37 @@ const TabContent = _ref => {
 };
 TabContent.displayName = COMPONENT_NAME$1;
 
-const COMPONENT_NAME = 'TabRoot';
-const TabRoot = _ref => {
-  let {
-    children,
-    customRootClass = '',
-    className = '',
-    color = undefined,
-    ...props
-  } = _ref;
-  const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME);
+var _excluded$1 = ["children", "customRootClass", "className", "color"];
+var COMPONENT_NAME = 'TabRoot';
+var TabRoot = function TabRoot(_ref) {
+  var children = _ref.children,
+    _ref$customRootClass = _ref.customRootClass,
+    customRootClass = _ref$customRootClass === void 0 ? '' : _ref$customRootClass,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    _ref$color = _ref.color,
+    color = _ref$color === void 0 ? undefined : _ref$color,
+    props = _objectWithoutProperties(_ref, _excluded$1);
+  var rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME);
   if (color) {
     props['data-accent-color'] = color;
   }
   return /*#__PURE__*/React.createElement("div", _extends({
-    className: `${rootClass} ${className}`
+    className: "".concat(rootClass, " ").concat(className)
   }, props), children);
 };
 TabRoot.displayName = COMPONENT_NAME;
 
-const Tabs = _ref => {
-  let {
-    tabs = [],
-    ...props
-  } = _ref;
+var _excluded = ["tabs"];
+var Tabs = function Tabs(_ref) {
+  var _ref$tabs = _ref.tabs,
+    tabs = _ref$tabs === void 0 ? [] : _ref$tabs,
+    props = _objectWithoutProperties(_ref, _excluded);
   // This should be a value <`tabs.value`> that is passed in from the parent component
-  const [activeTab, setActiveTab] = useState(tabs[0].value || '');
+  var _useState = useState(tabs[0].value || ''),
+    _useState2 = _slicedToArray(_useState, 2),
+    activeTab = _useState2[0],
+    setActiveTab = _useState2[1];
   return /*#__PURE__*/React.createElement(TabRoot, props, /*#__PURE__*/React.createElement(TabList, {
     activeTab: activeTab,
     setActiveTab: setActiveTab,

package/dist/components/Text.js

@@ -15,35 +15,64 @@ function _extends() {
   };
   return _extends.apply(this, arguments);
 }
+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 _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;
+}
 
-const RAD_UI_CLASS_PREFIX = 'rad-ui';
-const customClassSwitcher = function (customRootClass) {
-  let componentName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+var RAD_UI_CLASS_PREFIX = 'rad-ui';
+var customClassSwitcher = function customClassSwitcher(customRootClass) {
+  var componentName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
   // applies a custom root class the user provides, else applies the default rad-ui classes to the component
   // rad ui's classes are based on this logic
 
   // add dashes between capitalized words
-  const componentClassName = componentName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+  var componentClassName = componentName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
   if (customRootClass) return customRootClass;
-  if (componentName) return `${RAD_UI_CLASS_PREFIX}-${componentClassName}`;
+  if (componentName) return "".concat(RAD_UI_CLASS_PREFIX, "-").concat(componentClassName);
   return '';
 };
 
+var _excluded = ["children", "customRootClass", "className"];
+
 // Can be rendered as p, label, div, span, etc.
 // TODO: Add as prop support
 // TODO: Add a core reusable function to check and render an as prop
 
-const COMPONENT_NAME = 'Text';
-const Text = _ref => {
-  let {
-    children,
-    customRootClass = '',
-    className = '',
-    ...props
-  } = _ref;
-  const rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME);
+var COMPONENT_NAME = 'Text';
+var Text = function Text(_ref) {
+  var children = _ref.children,
+    _ref$customRootClass = _ref.customRootClass,
+    customRootClass = _ref$customRootClass === void 0 ? '' : _ref$customRootClass,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? '' : _ref$className,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var rootClass = customClassSwitcher(customRootClass, COMPONENT_NAME);
   return /*#__PURE__*/React.createElement("p", _extends({
-    className: `${rootClass} ${className}`
+    className: "".concat(rootClass, " ").concat(className)
   }, props), children);
 };
 Text.displayName = COMPONENT_NAME;

package/dist/components/TextArea.js

@@ -1,7 +1,8 @@
 'use client';
 import React from 'react';
 
-const TextArea = _ref => {
+var TextArea = function TextArea(_ref) {
+  _ref.children;
   return /*#__PURE__*/React.createElement("textarea", null);
 };