linear-react-components-ui 1.1.20-beta.33 → 1.1.20-beta.34

package/lib/tabs/context.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TabsContext = void 0;
+exports.TabsProvider = TabsProvider;
+var _react = _interopRequireWildcard(require("react"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _tabHelpers = require("./tabHelpers");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const TabsContext = exports.TabsContext = /*#__PURE__*/(0, _react.createContext)({});
+function TabsProvider(_ref) {
+  let {
+    children,
+    tabs: tabsProp,
+    container,
+    selectedTab = null,
+    onTabChange,
+    onTabClose,
+    tabsWidth: tabsWidthProp,
+    firstTabIdent = false
+  } = _ref;
+  const [selectedTabId, setSelectedTabId] = _react.default.useState(selectedTab);
+  const [containerWidth, setContainerWidth] = (0, _react.useState)(() => {
+    return container.current?.clientWidth ?? 0;
+  });
+  const [tabs, setTabs] = (0, _react.useState)((0, _tabHelpers.getTabs)(tabsProp));
+  const menuRef = (0, _react.useRef)(null);
+  const menuSize = (menuRef.current?.clientWidth ?? 0) - 38 - (firstTabIdent ? 15 : 0);
+  const tabsWidth = (0, _react.useMemo)(() => {
+    if (typeof tabsWidthProp === 'string') return tabsWidthProp === 'auto' ? 100 : parseInt(tabsWidthProp) || 100;
+    return tabsWidthProp;
+  }, [tabsWidthProp]);
+  const maxTabs = Math.round(menuSize / tabsWidth);
+  if (selectedTab && selectedTab !== selectedTabId) {
+    setSelectedTabId(selectedTab);
+  }
+  if (tabs.length > 0 && selectedTabId === null) {
+    setSelectedTabId(tabs[0]?.id);
+  }
+  const dropdownTabs = (0, _react.useMemo)(() => {
+    if (menuSize === 0) return [];
+    return tabs.slice(maxTabs);
+  }, [tabs, maxTabs, containerWidth]);
+  const menuTabs = (0, _react.useMemo)(() => {
+    return tabs.slice(0, maxTabs);
+  }, [tabs, maxTabs, containerWidth]);
+  const tabsCount = tabs.length;
+  const updateTabs = (0, _react.useCallback)(tabId => {
+    const tabInDropdownIndex = dropdownTabs.findIndex(tab => tab.id === tabId);
+    if (tabInDropdownIndex !== -1) {
+      const tabIndex = tabs.findIndex(tab => tab.id === tabId);
+      const tabInDropdown = dropdownTabs[tabInDropdownIndex];
+      setTabs(prevState => {
+        prevState.splice(tabIndex, 1);
+        return [tabInDropdown, ...prevState];
+      });
+    }
+  }, [setTabs, menuTabs, tabs, dropdownTabs]);
+  const selectTab = (0, _react.useCallback)(tabId => {
+    updateTabs(tabId);
+    setSelectedTabId(tabId);
+    if (onTabChange) {
+      onTabChange(tabId);
+    }
+  }, [onTabChange, setSelectedTabId, updateTabs]);
+  const removeTab = (0, _react.useCallback)(tabId => {
+    const tabIndex = tabs.findIndex(tab => tab.id === tabId);
+    const newSelectedTab = tabIndex === 0 ? tabs[tabIndex + 1] : tabs[tabIndex - 1];
+    if (selectedTabId === tabId) {
+      selectTab(newSelectedTab.id);
+    }
+    if (tabIndex !== -1) {
+      setTabs(prevState => {
+        prevState.splice(tabIndex, 1);
+        return prevState;
+      });
+    }
+    if (onTabClose) {
+      onTabClose(String(tabId));
+    }
+  }, [onTabClose, tabs, dropdownTabs, selectedTabId]);
+  const onResizeContainer = (0, _react.useCallback)(contentRect => {
+    setContainerWidth(contentRect.width);
+  }, [setContainerWidth]);
+  (0, _react.useEffect)(() => {
+    const newTabs = (0, _tabHelpers.getTabs)(tabsProp);
+    if (newTabs !== tabs) {
+      const includedTabs = _lodash.default.differenceBy(newTabs, tabs, 'id');
+      const excludedTabsIds = _lodash.default.differenceBy(tabs, newTabs, 'id').map(tab => tab.id);
+      setTabs(prevState => {
+        let currentTabs = prevState;
+        if (excludedTabsIds) {
+          currentTabs = currentTabs.filter(tab => !excludedTabsIds.includes(tab.id));
+        }
+        return [...currentTabs, ...includedTabs];
+      });
+    }
+  }, [tabsProp]);
+  (0, _react.useEffect)(() => {
+    const resizeObserver = new ResizeObserver(_ref2 => {
+      let [entry] = _ref2;
+      onResizeContainer(entry.contentRect);
+    });
+    if (container.current) resizeObserver.observe(container.current);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [container.current, onResizeContainer]);
+  return /*#__PURE__*/_react.default.createElement(TabsContext.Provider, {
+    value: {
+      tabs,
+      menuTabs,
+      dropdownTabs,
+      containerWidth,
+      tabsCount,
+      updateTabs,
+      selectTab,
+      selectedTabId,
+      removeTab,
+      menuRef
+    }
+  }, children);
+}

package/lib/tabs/index.d.ts

@@ -0,0 +1,12 @@
+export { default as TabPanel } from './Panel.js';
+import { ITabsPros } from './types.js';
+import 'react';
+import '../@types/Size.js';
+import '../@types/Position.js';
+import '../@types/PermissionAttr.js';
+import '../@types/Icon.js';
+import '../icons/helper.js';
+
+declare const Tabs: ({ toolbar, toolBarRef, children, firstTabIdent, handlerTabClick, handlerCloseTab, style, tabMenuSize, tabMenuAlign, tabMenuPosition, customClassForToolBar, tabsWidth, ...props }: ITabsPros) => JSX.Element;
+
+export { Tabs as default };

package/lib/tabs/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TabPanel", {
+  enumerable: true,
+  get: function () {
+    return _Panel.default;
+  }
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _Menu = _interopRequireDefault(require("./Menu"));
+var _Panel = _interopRequireDefault(require("./Panel"));
+var _tabHelpers = require("./tabHelpers");
+require("../assets/styles/tabs.scss");
+var _context = require("./context");
+const _excluded = ["toolbar", "toolBarRef", "children", "firstTabIdent", "handlerTabClick", "handlerCloseTab", "style", "tabMenuSize", "tabMenuAlign", "tabMenuPosition", "customClassForToolBar", "tabsWidth"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const Tabs = _ref => {
+  let {
+      toolbar,
+      toolBarRef,
+      children,
+      firstTabIdent,
+      handlerTabClick,
+      handlerCloseTab,
+      style = {},
+      tabMenuSize = 'default',
+      tabMenuAlign = 'left',
+      tabMenuPosition = 'top',
+      customClassForToolBar = '',
+      tabsWidth = 'auto'
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const containerRef = (0, _react.useRef)(null);
+  const content = (0, _react.useMemo)(() => {
+    const menu = /*#__PURE__*/_react.default.createElement(_Menu.default, {
+      toolbar: toolbar,
+      tabWidth: tabsWidth,
+      customClassForToolBar: customClassForToolBar,
+      tabMenuSize: tabMenuSize,
+      tabMenuAlign: tabMenuAlign,
+      firstTabIdent: firstTabIdent
+    });
+    if (tabMenuPosition === 'top' || tabMenuPosition === 'left') {
+      return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, menu, children);
+    }
+    return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, children, menu);
+  }, [children, tabMenuPosition]);
+  return /*#__PURE__*/_react.default.createElement(_context.TabsProvider, _extends({
+    tabs: children,
+    container: containerRef,
+    onTabChange: handlerTabClick,
+    onTabClose: handlerCloseTab,
+    tabsWidth: tabsWidth,
+    firstTabIdent: firstTabIdent
+  }, props), /*#__PURE__*/_react.default.createElement("div", {
+    ref: containerRef,
+    className: (0, _tabHelpers.tabsClass)(tabMenuPosition),
+    style: style
+  }, content));
+};
+var _default = exports.default = Tabs;

package/lib/tabs/tabHelpers.d.ts

@@ -0,0 +1,12 @@
+import React__default from 'react';
+import { Position } from '../@types/Position.js';
+
+declare function getCurrentThreshold(scrollableElement: HTMLDivElement, scrollThreshold: number): number;
+declare const getTabs: (tabsProp: React__default.ReactNode) => any[];
+declare function tabsClass(tabMenuPosition: Exclude<Position, 'center'>): string;
+declare function menuStyles(tabMenuAlign: Position): {
+    justifyContent: string;
+};
+declare const onDeniedOptions: string[];
+
+export { getCurrentThreshold, getTabs, menuStyles, onDeniedOptions, tabsClass };

package/lib/tabs/tabHelpers.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCurrentThreshold = getCurrentThreshold;
+exports.getTabs = void 0;
+exports.menuStyles = menuStyles;
+exports.onDeniedOptions = void 0;
+exports.tabsClass = tabsClass;
+var _react = _interopRequireDefault(require("react"));
+var _permissionValidations = require("../permissionValidations");
+const _excluded = ["children"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
+function getCurrentThreshold(scrollableElement, scrollThreshold) {
+  const MIN_THRESHOLD = 0;
+  const MAX_THRESHOLD = 1;
+  if (scrollThreshold < MIN_THRESHOLD) return MIN_THRESHOLD;
+  if (scrollThreshold > MAX_THRESHOLD) return MAX_THRESHOLD;
+  const {
+    scrollHeight,
+    clientHeight
+  } = scrollableElement;
+  const offsetHeight = scrollHeight - clientHeight;
+  const calculatedScrollThreshold = Math.round(scrollHeight * scrollThreshold);
+  const maxScrollThreshold = Math.round(offsetHeight - offsetHeight * 0.3);
+  return Math.min(calculatedScrollThreshold, maxScrollThreshold);
+}
+const getTabs = tabsProp => {
+  const tabs = _react.default.Children.map(tabsProp, child => {
+    if (!child || ! /*#__PURE__*/_react.default.isValidElement(child)) return null;
+    const _child$props = child.props,
+      {
+        children: childrenProp
+      } = _child$props,
+      props = _objectWithoutProperties(_child$props, _excluded);
+    return props;
+  }) || [];
+  return tabs.filter(tab => !tab.hidden);
+};
+
+/**
+ * Get the css class according to the options passed to the Tabs Component
+ */
+exports.getTabs = getTabs;
+const positionsMenuClass = {
+  top: '',
+  left: 'menu-left',
+  bottom: 'menu-bottom',
+  right: 'menu-right'
+};
+function tabsClass(tabMenuPosition) {
+  let cssClass = 'tabs-component ';
+  cssClass += positionsMenuClass[tabMenuPosition];
+  return cssClass;
+}
+
+/**
+ * Menu Styles for tab menus
+ */
+const flextJustifyContent = {
+  left: 'flex-start',
+  top: 'flex-start',
+  right: 'flex-end',
+  bottom: 'flex-end',
+  center: 'center'
+};
+function menuStyles(tabMenuAlign) {
+  return {
+    justifyContent: flextJustifyContent[tabMenuAlign]
+  };
+}
+const onDeniedOptions = exports.onDeniedOptions = [_permissionValidations.OPTIONS_ON_DENIED.disabled, _permissionValidations.OPTIONS_ON_DENIED.unvisible, _permissionValidations.OPTIONS_ON_DENIED.hideContent];

package/lib/tabs/types.d.ts

@@ -0,0 +1,98 @@
+import { RefObject, CSSProperties, ReactElement, ReactNode } from 'react';
+import { Size } from '../@types/Size.js';
+import { Position } from '../@types/Position.js';
+import { PermissionAttr } from '../@types/PermissionAttr.js';
+import { IconNames } from '../@types/Icon.js';
+import '../icons/helper.js';
+
+type TabsContextType = {
+    tabs: TabProps[];
+    menuTabs: TabProps[];
+    dropdownTabs: TabProps[];
+    selectedTabId: string | number | null;
+    selectTab: (tabId: string | number) => void;
+    updateTabs: (tabId: string | number) => void;
+    removeTab: (tabId: string | number) => void;
+    containerWidth: number;
+    tabsCount: number;
+    menuRef: RefObject<HTMLUListElement>;
+};
+interface TabsProviderProps {
+    children: React.ReactNode;
+    tabs: React.ReactNode;
+    container: RefObject<HTMLDivElement>;
+    tabsWidth: number | string;
+    selectedTab?: string | number | null;
+    onTabChange?: (tabId: string | number) => void;
+    onTabClose?: (tabId: string) => void;
+    firstTabIdent?: boolean;
+}
+interface ITabsPros {
+    style?: CSSProperties;
+    toolbar?: ReactElement;
+    toolBarRef?: (value: HTMLDivElement | null) => void;
+    children?: ReactNode;
+    selectedTab?: string | number;
+    tabMenuSize?: Size;
+    tabMenuAlign?: Position;
+    firstTabIdent?: boolean;
+    tabMenuPosition?: Exclude<Position, 'center'>;
+    handlerTabClick?: (id?: string | number) => void;
+    handlerCloseTab?: (id?: string, idx?: string) => void;
+    customClassForToolBar?: string;
+    tabsWidth?: string | number;
+}
+interface TabProps {
+    id: string | number;
+    title: string;
+    iconAlign?: Extract<Position, 'left' | 'right'>;
+    iconName?: IconNames;
+    icon?: ReactElement;
+    disabled?: boolean;
+    permissionAttr?: PermissionAttr;
+    tabWidth?: string | number;
+    tabMenuSize?: Size;
+    tabMenuAlign?: Position;
+    tooltip?: string;
+    tooltipPosition?: Exclude<Position, 'center'>;
+    tooltipWidth?: string | number;
+    closeable?: boolean;
+    tabsLength?: number;
+}
+interface MenuProps {
+    toolbar?: ReactElement;
+    customClass?: string;
+    customClassForToolBar?: string;
+    tabWidth?: string | number;
+    tabMenuAlign?: Position;
+    selectedTabId?: string;
+    firstTabIdent?: boolean;
+    tabs?: TabProps[];
+    tabMenuSize?: Size;
+    handlerClick?: (id?: string) => void;
+    handlerRemovePanel?: (id?: string, idx?: number, bool?: boolean) => void;
+}
+interface DropdownProps extends MenuProps {
+}
+interface PanelProps {
+    id?: string;
+    icon?: ReactElement;
+    title?: string;
+    hidden?: boolean;
+    tooltip?: string;
+    disabled?: boolean;
+    closable?: boolean;
+    iconName?: IconNames;
+    children?: ReactNode;
+    closeable?: boolean;
+    iconAlign?: Extract<Position, 'left' | 'right'>;
+    customClass?: string;
+    tooltipWidth?: string | number;
+    onEndReached?: () => void;
+    permissionAttr?: PermissionAttr;
+    tooltipPosition?: Exclude<Position, 'center'>;
+    onEndReachedThreshold?: number;
+    style?: CSSProperties;
+}
+
+export { DropdownProps, ITabsPros, MenuProps, PanelProps, TabProps, TabsContextType, TabsProviderProps };

package/lib/tabs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/tabs/useTabs.d.ts

@@ -0,0 +1,11 @@
+import { TabsContextType } from './types.js';
+import 'react';
+import '../@types/Size.js';
+import '../@types/Position.js';
+import '../@types/PermissionAttr.js';
+import '../@types/Icon.js';
+import '../icons/helper.js';
+
+declare function useTabs(): TabsContextType;
+
+export { useTabs };

package/lib/tabs/useTabs.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useTabs = useTabs;
+var _react = require("react");
+var _context = require("./context");
+function useTabs() {
+  return (0, _react.useContext)(_context.TabsContext);
+}

package/lib/textContent/index.d.ts

@@ -0,0 +1,22 @@
+import React__default, { MutableRefObject } from 'react';
+import { WithTooltipProps } from '../internals/types.js';
+import '../@types/PermissionAttr.js';
+import '../@types/Position.js';
+
+interface TextContentProps extends React__default.HTMLAttributes<HTMLElement>, WithTooltipProps {
+    as?: 'span' | 'strong' | 'p';
+    label?: string | string[];
+    styleForLabel?: object;
+    labelUppercase?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    targetRef?: (ref: HTMLSpanElement | null) => void;
+    labelRef?: MutableRefObject<HTMLSpanElement | null>;
+    onHoverLabel?: (e: React__default.MouseEvent<HTMLSpanElement, MouseEvent>) => void;
+}
+declare const _default: {
+    (props: TextContentProps & React__default.RefAttributes<HTMLElement>): JSX.Element;
+    displayName: string;
+};
+
+export { _default as default };

package/lib/textContent/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+require("../assets/styles/textContent.scss");
+var _withTooltip = _interopRequireDefault(require("../internals/withTooltip"));
+var _lodash = _interopRequireDefault(require("lodash"));
+const _excluded = ["as", "children", "className", "label", "styleForLabel", "disabled", "targetRef", "labelRef", "onHoverLabel"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const TextContent = /*#__PURE__*/(0, _react.forwardRef)((_ref, ref) => {
+  let {
+      as: Comp = 'span',
+      children,
+      className,
+      label,
+      styleForLabel,
+      disabled,
+      targetRef,
+      labelRef,
+      onHoverLabel
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const typedRef = ref;
+  const restProps = _lodash.default.omit(props, ['tooltipWidth', 'tooltip', 'tooltipPosition', 'labelUppercase']);
+  return /*#__PURE__*/_react.default.createElement(Comp, _extends({
+    ref: typedRef,
+    style: styleForLabel,
+    className: `text-content-component ${className}`,
+    "data-textcontent": Comp,
+    onMouseEnter: onHoverLabel
+  }, restProps), children);
+});
+TextContent.displayName = 'TextContent';
+var _default = exports.default = (0, _withTooltip.default)(TextContent);

package/lib/toolbar/ButtonBar.d.ts

@@ -0,0 +1,12 @@
+import { IButtonBarProps } from './types.js';
+import 'react';
+import '../@types/ButtonTypes.js';
+import '../@types/Position.js';
+import '../@types/Size.js';
+import '../treeview/types.js';
+import '../@types/Icon.js';
+import '../icons/helper.js';
+
+declare const ButtonBar: ({ size, icon, onClick, iconName, transparent, customClass, type, iconAlign, label, ...props }: IButtonBarProps) => JSX.Element;
+
+export { ButtonBar as default };

package/lib/toolbar/ButtonBar.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _buttons = _interopRequireWildcard(require("../buttons"));
+var _helpers = _interopRequireDefault(require("./helpers"));
+const _excluded = ["size", "icon", "onClick", "iconName", "transparent", "customClass", "type", "iconAlign", "label"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const ButtonBar = _ref => {
+  let {
+      size,
+      icon,
+      onClick,
+      iconName,
+      transparent,
+      customClass,
+      type = 'default',
+      iconAlign = 'left',
+      label = ''
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const {
+    skeletonize
+  } = (0, _react.useContext)(_helpers.default);
+  const getProps = () => _objectSpread(_objectSpread({}, props), {}, {
+    size,
+    icon,
+    label,
+    onClick,
+    iconName,
+    iconAlign,
+    transparent,
+    skeletonize,
+    boxShadow: false,
+    customClass: `buttonbar ${customClass}`
+  });
+  return {
+    default: /*#__PURE__*/_react.default.createElement(_buttons.default, getProps()),
+    primary: /*#__PURE__*/_react.default.createElement(_buttons.PrimaryButton, getProps()),
+    danger: /*#__PURE__*/_react.default.createElement(_buttons.DangerButton, getProps()),
+    info: /*#__PURE__*/_react.default.createElement(_buttons.InfoButton, getProps()),
+    success: /*#__PURE__*/_react.default.createElement(_buttons.SuccessButton, getProps()),
+    warning: /*#__PURE__*/_react.default.createElement(_buttons.WarningButton, getProps()),
+    add: /*#__PURE__*/_react.default.createElement(_buttons.AddButton, getProps()),
+    cancel: /*#__PURE__*/_react.default.createElement(_buttons.CancelButton, getProps()),
+    destroy: /*#__PURE__*/_react.default.createElement(_buttons.DestroyButton, getProps()),
+    edit: /*#__PURE__*/_react.default.createElement(_buttons.EditButton, getProps()),
+    save: /*#__PURE__*/_react.default.createElement(_buttons.SaveButton, getProps()),
+    activate: /*#__PURE__*/_react.default.createElement(_buttons.ActivateButton, getProps()),
+    inactivate: /*#__PURE__*/_react.default.createElement(_buttons.InactivateButton, getProps()),
+    restore: /*#__PURE__*/_react.default.createElement(_buttons.RestoreButton, getProps())
+  }[type];
+};
+var _default = exports.default = ButtonBar;

package/lib/toolbar/LabelBar.d.ts

@@ -0,0 +1,12 @@
+import { ILabelBarProps } from './types.js';
+import 'react';
+import '../@types/ButtonTypes.js';
+import '../@types/Position.js';
+import '../@types/Size.js';
+import '../treeview/types.js';
+import '../@types/Icon.js';
+import '../icons/helper.js';
+
+declare const LabelBar: ({ size, icon, children, iconName, style, type, bordered, ...props }: ILabelBarProps) => JSX.Element;
+
+export { LabelBar as default };

package/lib/toolbar/LabelBar.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _labels = _interopRequireWildcard(require("../labels"));
+var _helpers = _interopRequireDefault(require("./helpers"));
+const _excluded = ["size", "icon", "children", "iconName", "style", "type", "bordered"];
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, 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 _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
+function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
+const LabelBar = _ref => {
+  let {
+      size,
+      icon,
+      children,
+      iconName,
+      style = {},
+      type = 'default',
+      bordered = false
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const styles = _objectSpread({
+    lineHeight: 'unset',
+    padding: '7px 10px 6px'
+  }, style);
+  const {
+    skeletonize
+  } = (0, _react.useContext)(_helpers.default);
+  const getProps = () => _objectSpread(_objectSpread({}, props), {}, {
+    size,
+    icon,
+    children,
+    iconName,
+    style: styles,
+    bordered,
+    skeletonize,
+    customClass: 'labelbar'
+  });
+  return {
+    default: /*#__PURE__*/_react.default.createElement(_labels.default, getProps()),
+    primary: /*#__PURE__*/_react.default.createElement(_labels.PrimaryLabel, getProps()),
+    danger: /*#__PURE__*/_react.default.createElement(_labels.DangerLabel, getProps()),
+    info: /*#__PURE__*/_react.default.createElement(_labels.InfoLabel, getProps()),
+    success: /*#__PURE__*/_react.default.createElement(_labels.SuccessLabel, getProps()),
+    warning: /*#__PURE__*/_react.default.createElement(_labels.WarningLabel, getProps())
+  }[type];
+};
+var _default = exports.default = LabelBar;

package/lib/toolbar/Separator.d.ts

@@ -0,0 +1,3 @@
+declare const Separator: () => JSX.Element;
+
+export { Separator as default };