blue-react 9.12.0 → 9.12.2

package/dist/components/A.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface AProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+}
+/**
+ * The `<a>` element automatically sets `rel="noreferrer"` for external links with `target="_blank"`.\
+ * `A` allows all props of the `<a>` element.\
+ * `<A href="https://example.com" target="_blank">Example</A>` ➡️ `<a href="https://example.com" target="_blank" rel="noreferrer">Example</a>`
+ */
+export default function A({ children, rel, ...rest }: AProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ActionMenu.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import { breakOption } from "./shared";
+export declare const ActionMenuContext: React.Context<{
+    breakOption: breakOption | "none";
+}>;
+export interface ActionMenuProps {
+    /**
+     * Hides the toggle button in mobile view. Can be useful when using multiple ActionMenus and not show the toggle button for each menu.
+     */
+    hideToggleAction?: boolean;
+    children?: any;
+    /**
+     * Icon component for the toggle icon.
+     */
+    toggleIcon?: any;
+    className?: string;
+    /**
+     * "sm" | "md" | "lg" | "xl" | "none". Default is "lg". The responsive breakpoint at which the menu will be shown as a dropdown.
+     */
+    break?: breakOption | "none";
+}
+/**
+ * The Action Menu on the top right of a page. You can place Actions here which are in context of the current page.
+ */
+export default function ActionMenu(props: ActionMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Body.d.ts

@@ -0,0 +1,21 @@
+import { breakOption } from "./shared";
+export interface BodyProps {
+    id?: string;
+    className?: string;
+    /**
+     * Class name for the container. More info: https://getbootstrap.com/docs/4.0/layout/overview/#containers
+     */
+    containerClass?: string;
+    /**
+     * Set `true` if this page uses `<Actions />`, so this component will get enough padding to avoid overlapping of the content.
+     */
+    hasActions?: boolean;
+    break?: breakOption;
+    onClick?: (event: any) => void;
+    children?: any;
+}
+/**
+ * @deprecated With the new layout design, you don't need this anymore.
+ * Contains the content of the page.
+ */
+export default function Body({ id, className, containerClass, hasActions, onClick, children, ...rest }: BodyProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Chevron.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from "react";
+export interface ChevronProps {
+    /**
+     * Indicates if open or not.
+     */
+    open?: boolean;
+    /**
+     * By default the chevron points to the right when closed. Set mirrored and it will point to the left.
+     */
+    mirrored?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * Chevron icon component with open state.
+ */
+export default function Chevron({ open, mirrored, className, style }: ChevronProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Chevron.js

@@ -23,6 +23,7 @@ function Chevron(_ref) {
       mirrored = _ref.mirrored,
       className = _ref.className,
       style = _ref.style;
+  var prefersReducedMotion = window.matchMedia("(prefers-reduced-motion)").matches;
   return /*#__PURE__*/_react.default.createElement("svg", {
     xmlns: "http://www.w3.org/2000/svg",
     width: "1em",
@@ -33,7 +34,7 @@ function Chevron(_ref) {
       display: "inline-block",
       verticalAlign: "-0.125em",
       transform: "rotate(".concat(open && mirrored ? -90 : open ? 90 : 0, "deg)"),
-      transition: "transform 0.2s"
+      transition: prefersReducedMotion ? "none" : "transform 0.2s"
     }),
     viewBox: "0 0 16 16"
   }, mirrored ? /*#__PURE__*/_react.default.createElement("path", {

package/dist/components/HashRouter.d.ts

@@ -0,0 +1,76 @@
+import { Component, ReactNode } from "react";
+declare global {
+    interface Window {
+        blueHashRouterRef: any;
+    }
+}
+export interface HashRouterProps {
+    /**
+     * Registers pages for the built-in routing system. Example: `[{name: "home", component: <HomePage />}]`
+     */
+    pages?: {
+        name: string;
+        component: ReactNode;
+    }[];
+    /**
+     * When `true`, always the "home" route will be rendered.
+     */
+    unrouteable?: boolean;
+    /**
+     * By default, the document title will automatically set. Set this prop to `true` to disable this behaviour.
+     */
+    disableTitleSet?: boolean;
+    /**
+     * Define a function, that will be fired when switching routes. When your function returns `true`, the default route behaviour will be blocked.
+     * You can use something like `window.blueHashRouterRef.setState({ blockRouting: onHashChange })` globally to set the value from anywhere in your app.
+     */
+    blockRouting?: (newMatch: string[], currentMatch: string[]) => void | boolean;
+    children?: any;
+}
+export interface HashRouterState {
+    match: any;
+    history: string[];
+    hash: string;
+    hashHistory: string[];
+    blockRouting?: (newMatch: string[], currentMatch: string[]) => void | boolean;
+}
+/**
+ * Component for simple hash routing. It's recommended to use solutions like `react-router-dom` for more complex routing.
+ *
+ * As soon this component is mounted, it is globally available under `window.blueHashRouterRef`.
+ * You can also append your own event listeners.
+ *
+ * Allowed events:
+ *
+ * * **componentDidUpdate** - Component was updated.
+ *   Example: `window.blueHashRouterRef.addEventListener("componentDidUpdate", (prevProps, prevState) => { })`
+ * * **pageDidShowAgain** - Page appeared again with the same old state. In the callback function you can reinitialize things.
+ *   Example: `window.blueHashRouterRef.addEventListener("pageDidShowAgain", "home", (prevProps, prevState) => { })`
+ * * **pageDidHide** - This page disappeared and another page appears instead.
+ *   Example: `window.blueHashRouterRef.addEventListener("pageDidHide", "home", (prevProps, prevState) => { })`
+ *
+ * Method to add event listeners:
+ * * `window.blueHashRouterRef.`**addEventListener**`(eventName: string, param2: any, param3: any, listenerId?: string)`
+ *
+ * Methods to remove event listeners:
+ * * `window.blueHashRouterRef.`**removeEventListener**`(eventName: string, listenerId: string)`
+ * * `window.blueHashRouterRef.`**removeDuplicatedEventListeners**`()` - Will automatically be called when running `addEventListener`
+ */
+export default class HashRouter extends Component<HashRouterProps, HashRouterState> {
+    defaultMatch: string[];
+    eventListeners: any[];
+    constructor(props: HashRouterProps);
+    onHashChange(): void;
+    static get defaultProps(): {
+        unrouteable: boolean;
+        disableTitleSet: boolean;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: HashRouterProps, prevState: HashRouterState): void;
+    initMatch(): void;
+    addEventListener(param1: any, param2: any, param3: any, listenerId?: string): void;
+    removeEventListener(type: string, listenerId: string): void;
+    removeDuplicatedEventListeners(): void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/dist/components/HashRouter.js

@@ -0,0 +1,176 @@
+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); }
+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); }
+import React, { Component } from "react";
+/**
+ * Component for simple hash routing. It's recommended to use solutions like `react-router-dom` for more complex routing.
+ *
+ * As soon this component is mounted, it is globally available under `window.blueHashRouterRef`.
+ * You can also append your own event listeners.
+ *
+ * Allowed events:
+ *
+ * * **componentDidUpdate** - Component was updated.
+ *   Example: `window.blueHashRouterRef.addEventListener("componentDidUpdate", (prevProps, prevState) => { })`
+ * * **pageDidShowAgain** - Page appeared again with the same old state. In the callback function you can reinitialize things.
+ *   Example: `window.blueHashRouterRef.addEventListener("pageDidShowAgain", "home", (prevProps, prevState) => { })`
+ * * **pageDidHide** - This page disappeared and another page appears instead.
+ *   Example: `window.blueHashRouterRef.addEventListener("pageDidHide", "home", (prevProps, prevState) => { })`
+ *
+ * Method to add event listeners:
+ * * `window.blueHashRouterRef.`**addEventListener**`(eventName: string, param2: any, param3: any, listenerId?: string)`
+ *
+ * Methods to remove event listeners:
+ * * `window.blueHashRouterRef.`**removeEventListener**`(eventName: string, listenerId: string)`
+ * * `window.blueHashRouterRef.`**removeDuplicatedEventListeners**`()` - Will automatically be called when running `addEventListener`
+ */
+var HashRouter = /*#__PURE__*/function (_Component) {
+  function HashRouter(props) {
+    var _this;
+    _classCallCheck(this, HashRouter);
+    _this = _callSuper(this, HashRouter, [props]);
+    window.blueHashRouterRef = _this;
+    _this.defaultMatch = ["home"];
+    _this.state = {
+      match: null,
+      history: [],
+      hash: window.location.hash,
+      hashHistory: [],
+      blockRouting: props.blockRouting || undefined
+    };
+    _this.eventListeners = [];
+    return _this;
+  }
+  _inherits(HashRouter, _Component);
+  return _createClass(HashRouter, [{
+    key: "onHashChange",
+    value: function onHashChange() {
+      window.blueHashRouterRef.initMatch();
+    }
+  }, {
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.initMatch();
+      window.addEventListener("hashchange", this.onHashChange);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      window.removeEventListener("hashchange", this.onHashChange);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      var _this2 = this;
+      if (prevProps.blockRouting !== this.props.blockRouting && this.props.blockRouting !== this.state.blockRouting) {
+        this.setState({
+          blockRouting: this.props.blockRouting
+        });
+      }
+      this.eventListeners.forEach(function (eventListener) {
+        if (eventListener[0] === "componentDidUpdate") {
+          eventListener[1](prevProps, prevState);
+        }
+        if (eventListener[0] === "pageDidShowAgain") {
+          var pageId = eventListener[1];
+          var callback = eventListener[2];
+          if (prevState.hash !== _this2.state.hash && _this2.state.match[0] === pageId) {
+            callback(prevProps, prevState);
+          }
+        }
+        if (eventListener[0] === "pageDidHide") {
+          var _pageId = eventListener[1];
+          var _callback = eventListener[2];
+          if (prevState.hash !== _this2.state.hash && prevState.match[0] === _pageId) {
+            _callback(prevProps, prevState);
+          }
+        }
+      });
+    }
+  }, {
+    key: "initMatch",
+    value: function initMatch() {
+      var newMatch;
+      if (window.location.hash && window.location.hash !== "" && window.location.hash !== "#/") {
+        newMatch = window.location.hash.replace("#", "").split("/").filter(function (n) {
+          return n !== "";
+        });
+      } else {
+        newMatch = this.defaultMatch;
+      }
+      if (this.props.unrouteable) {
+        newMatch = this.defaultMatch;
+      }
+      if (this.state.blockRouting && this.state.blockRouting(newMatch, this.state.match) === true) {
+        window.location.hash = this.state.hash;
+      } else {
+        if (!(this.state.history.indexOf(newMatch[0]) > -1)) {
+          this.state.history.push(newMatch[0]);
+        }
+        this.setState({
+          match: newMatch,
+          history: this.state.history,
+          hash: window.location.hash,
+          hashHistory: this.state.hashHistory.concat([window.location.hash])
+        });
+      }
+    }
+  }, {
+    key: "addEventListener",
+    value: function addEventListener(param1, param2, param3, listenerId) {
+      this.eventListeners.push([param1, param2, param3, listenerId]);
+      this.removeDuplicatedEventListeners();
+    }
+  }, {
+    key: "removeEventListener",
+    value: function removeEventListener(type, listenerId) {
+      this.eventListeners = this.eventListeners.filter(function (param) {
+        if (param[0] !== type) {
+          return param;
+        } else if (param[0] === type && param[3] !== listenerId) {
+          return param;
+        }
+      });
+    }
+  }, {
+    key: "removeDuplicatedEventListeners",
+    value: function removeDuplicatedEventListeners() {
+      this.eventListeners = this.eventListeners.filter(function (value, index, self) {
+        return index === self.findIndex(function (t) {
+          return t[3] === value[3] && t[0] === value[0];
+        });
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props$pages,
+        _this3 = this;
+      return /*#__PURE__*/React.createElement(React.Fragment, null, (_this$props$pages = this.props.pages) === null || _this$props$pages === void 0 ? void 0 : _this$props$pages.map(function (page) {
+        return _this3.state.history.indexOf(page.name) > -1 && /*#__PURE__*/React.createElement("div", {
+          key: page.name,
+          className: "router-page " + (_this3.state.match[0] === page.name ? "active" : "d-none")
+        }, page.component);
+      }));
+    }
+  }], [{
+    key: "defaultProps",
+    get: function get() {
+      return {
+        unrouteable: false,
+        disableTitleSet: false
+      };
+    }
+  }]);
+}(Component);
+export { HashRouter as default };

package/dist/components/Header.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+export interface HeaderProps {
+    children?: ReactNode;
+    className?: string;
+}
+/**
+ * The top of a page.
+ */
+export default function Header({ children, className }: HeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/HeaderTitle.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from "react";
+export interface HeaderTitleProps {
+    /**
+     * Can be an image. Will be placed inside of the `src` attribute.
+     */
+    logo?: string;
+    logoAlt?: string;
+    /**
+     * Text next to the logo.
+     */
+    appTitle?: string;
+    children?: ReactNode;
+    /**
+     * Extends `className` from parent element.
+     */
+    className?: string;
+    /**
+     * Is the component used on the sidebar?
+     */
+    sidebar?: boolean;
+    /**
+     * By default, MenuItem is a `"a"`.
+     * If you want to have it another type, you can pass a component reference with this prop (e.g. `Link`).
+     */
+    elementType?: any;
+    /**
+     * Sets `to` prop, e.g. when you use the `Link` component from React Router.
+     */
+    to?: string;
+    href?: string;
+    /**
+     * Breadcrumb items to be shown.
+     */
+    breadcrumb?: ReactNode[];
+}
+/**
+ * The title area at the header bar.
+ * Depending on its content, the document's title will be set aswell (what will be shown in the browser title bar).
+ */
+export default function HeaderTitle({ logo, logoAlt, appTitle, children, className, sidebar, elementType, to, href, breadcrumb }: HeaderTitleProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/IconMenuItem.d.ts

@@ -0,0 +1,18 @@
+import { MenuItemProps } from "./MenuItem";
+export interface IconMenuItemProps extends MenuItemProps {
+    outerClass?: string;
+    /**
+     * Tooltip will be placed to the end/right by default. You can change the direction with this prop.
+     */
+    tooltipClass?: string;
+    /**
+     * When used inside of the sidebar: active indicator will be displayed underneath instead of before.
+     * The prop to `false` to disable this behavior.
+     */
+    horizontalOnOpenSidebar?: boolean;
+}
+/**
+ * Variant of `MenuItem` to primarily display an icon without a label.
+ * The label prop will be displayed as a tooltip.
+ */
+export default function IconMenuItem({ label, outerClass, tooltipClass, horizontalOnOpenSidebar, className, ...props }: IconMenuItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Intro.d.ts

@@ -0,0 +1,22 @@
+export interface IntroProps {
+    /**
+     * Can be an image. Will be placed inside of the `src` attribute.
+     */
+    logo?: string;
+    /**
+     * Max width from the logo.
+     */
+    logoMaxWidth?: string;
+    /**
+     * Text which will be placed under the logo.
+     */
+    title?: string;
+    /**
+     * Content
+     */
+    children?: any;
+}
+/**
+ * Can be used for a sign-in page.
+ */
+export default function Intro({ logo, logoMaxWidth, title, children }: IntroProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Layout/LayoutHeader.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export interface LayoutHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+export default function LayoutHeader({ children, className, ...rest }: LayoutHeaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Layout/LayoutHeader.js

@@ -0,0 +1,25 @@
+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); }
+var _excluded = ["children", "className"];
+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 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; }
+import React from "react";
+export default function LayoutHeader(_ref) {
+  var children = _ref.children,
+    className = _ref.className,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("header", _extends({
+    className: "d-flex justify-content-between position-relative h-100 ".concat(className),
+    style: _objectSpread({
+      color: "var(--blue-sidebar-color)",
+      background: "var(--blue-sidebar-bg)",
+      zIndex: "var(--blue-layout-header-z-index, 4)",
+      "--blue-menu-item-dropdown-bg": "var(--blue-sidebar-bg)"
+    }, rest.style)
+  }, rest), children);
+}

package/dist/components/Layout/LayoutMain.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface LayoutMainProps extends React.HTMLAttributes<HTMLDivElement> {
+    noPageBorder?: boolean;
+}
+export default function LayoutMain({ children, className, noPageBorder, ...rest }: LayoutMainProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Layout/LayoutMain.js

@@ -0,0 +1,17 @@
+var _excluded = ["children", "className", "noPageBorder"];
+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; }
+import React from "react";
+export default function LayoutMain(_ref) {
+  var children = _ref.children,
+    className = _ref.className,
+    _ref$noPageBorder = _ref.noPageBorder,
+    noPageBorder = _ref$noPageBorder === void 0 ? false : _ref$noPageBorder,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return /*#__PURE__*/React.createElement("div", _extends({
+    className: "w-100 h-100 p-1 pt-0 ".concat(className)
+  }, rest), /*#__PURE__*/React.createElement("div", {
+    className: "\"w-100 h-100 overflow-auto rounded-3 ".concat(noPageBorder ? "" : "border ", "bg-body shadow-sm\"")
+  }, children));
+}

package/dist/components/Layout.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface LayoutProps {
+    children?: React.ReactNode;
+    header?: React.ReactNode;
+    side?: React.ReactNode;
+    noPageBorder?: boolean;
+}
+/**
+ * A layout with header, side and main content area. Side is collapsible.
+ */
+export default function Layout({ children, header, side, noPageBorder }: LayoutProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/MenuItem.d.ts

@@ -0,0 +1,149 @@
+import React, { CSSProperties } from "react";
+export interface MenuItemProps {
+    /**
+     * Sets `to` prop, e.g. when you use the `NavLink` component from React Router.
+     */
+    to?: string;
+    /**
+     * Prop for components by React Router.
+     */
+    exact?: boolean;
+    href?: string;
+    onClick?: (event: React.MouseEvent) => void;
+    /**
+     * Will be fired after `onClick`
+     */
+    onClickAttached?: (event: React.MouseEvent) => void;
+    /**
+     * Icon component or a class name.
+     */
+    icon?: any;
+    /**
+     * Addition to class name of icon wrapper element
+     */
+    iconClassName?: string;
+    /**
+     * Icon component or a class name when the MenuItem is active.
+     */
+    iconForActive?: any;
+    /**
+     * Label of the link.
+     */
+    label?: any;
+    /**
+     * Addition to class name of label wrapper element
+     */
+    labelClassName?: string;
+    /**
+     * Addition to class name of caret
+     */
+    caretClassName?: string;
+    /**
+     * Addition to style of caret
+     */
+    caretStyle?: CSSProperties;
+    /**
+     * Should be set as active.
+     */
+    isActive?: boolean;
+    /**
+     * Set true to highlight the current menu item.
+     */
+    highlighted?: boolean;
+    /**
+     * When using Blue React's routing system: define this link as home page link.
+     */
+    isHome?: boolean;
+    /**
+     * Extends class name of the dropdown menu.
+     */
+    dropdownClassName?: string;
+    /**
+     * Extends style of the dropdown menu.
+     */
+    dropdownStyle?: CSSProperties;
+    /**
+     * Set children to create a nested `MenuItem` as a dropdown.
+     */
+    children?: any;
+    /**
+     * Defines class name.
+     */
+    className?: any;
+    /**
+     * Defines dropdown status from outside.
+     */
+    showDropdown?: boolean;
+    /**
+     * Callback when `showDropdown` changes.
+     */
+    onShowDropdown?: (showDropdown: boolean) => void;
+    /**
+     * Close on click outside.
+     */
+    supportOutside?: boolean;
+    /**
+     * Overrides default class list to be ignored on click outside.
+     * Hint: If you want this menu item to stay open when others will open, set:
+     * `outsideIgnoreClasses={["blue-menu-item-wrapper"]}`.
+     */
+    outsideIgnoreClasses?: string[];
+    /**
+     * By default, MenuItem is a `"button"`. If you set a `href`, it's a `"a"`.
+     * If you want to have it another type, you can pass a component reference with this prop (e.g. `Link`).
+     */
+    elementType?: any;
+    target?: string;
+    rel?: string;
+    title?: string;
+    type?: string;
+    /**
+     * Fired on the draggable target (the source element): occurs when the user starts to drag an element
+     */
+    onDragStart?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the draggable target (the source element): occurs when an element is being dragged
+     */
+    onDrag?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the draggable target (the source element): occurs when the user has finished dragging the element
+     */
+    onDragEnd?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the drop target: occurs when the dragged element enters the drop target
+     */
+    onDragEnter?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the drop target: occurs when the dragged element is over the drop target
+     */
+    onDragOver?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the drop target: occurs when the dragged element leaves the drop target
+     */
+    onDragLeave?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Fired on the drop target: occurs when the dragged element is dropped on the drop target
+     */
+    onDrop?: (event: React.DragEvent) => void | React.DragEventHandler;
+    /**
+     * Specifies whether an element is draggable or not.
+     *
+     * **Important:** To make draggable menu items work in Firefox, the elementType must not be `"button"`. Set it to something else, like `"div"`.
+     */
+    draggable?: boolean;
+    hideDraggableIcon?: boolean;
+    "data-tooltip"?: string;
+    /**
+     * Specifies whether an element is disabled or not.
+     */
+    disabled?: boolean;
+    /**
+     * Specifies style of an element.
+     */
+    style?: React.CSSProperties;
+    id?: string;
+}
+/**
+ * Link, button or custom component for Sidebar, Actions or ActionMenu
+ */
+export default function MenuItem(props: MenuItemProps): import("react/jsx-runtime").JSX.Element;