@pismo/marola 0.0.1-alpha.1 → 0.0.1-alpha.12

package/dist/components/Snackbar/Snackbar.js

@@ -0,0 +1,623 @@
+import '../../assets/Snackbar.css';
+import { jsx as h, jsxs as Y } from "react/jsx-runtime";
+import * as N from "react";
+import C, { useState as V, useRef as X } from "react";
+import { c as O } from "../../clsx-DB4S2d7J.js";
+import { Icon as K } from "../Icon/Icon.js";
+import { a as w, _ as j } from "../../objectWithoutPropertiesLoose-D7Cp0Pg_.js";
+import { g as $, a as z, e as H, b as U, P as t, c as J, d as Q } from "../../index-CqjC7P5Y.js";
+import { u as Z } from "../../useTimeout-DxF9kiZL.js";
+import { u as I } from "../../useEventCallback-vAfOD-oT.js";
+import { C as B } from "../../ClickAwayListener-HI1G6ob9.js";
+import { R as D } from "../../index-BJ8HbRCy.js";
+const W = "Snackbar";
+function ee(u) {
+  return $(W, u);
+}
+z(W, ["root"]);
+function te(u = {}) {
+  const {
+    autoHideDuration: s = null,
+    disableWindowBlurListener: a = !1,
+    onClose: r,
+    open: n,
+    resumeHideDuration: e
+  } = u, o = Z();
+  N.useEffect(() => {
+    if (!n)
+      return;
+    function l(d) {
+      d.defaultPrevented || (d.key === "Escape" || d.key === "Esc") && (r == null || r(d, "escapeKeyDown"));
+    }
+    return document.addEventListener("keydown", l), () => {
+      document.removeEventListener("keydown", l);
+    };
+  }, [n, r]);
+  const i = I((l, d) => {
+    r == null || r(l, d);
+  }), c = I((l) => {
+    !r || l == null || o.start(l, () => {
+      i(null, "timeout");
+    });
+  });
+  N.useEffect(() => (n && c(s), o.clear), [n, s, c, o]);
+  const m = (l) => {
+    r == null || r(l, "clickaway");
+  }, p = o.clear, E = N.useCallback(() => {
+    s != null && c(e ?? s * 0.5);
+  }, [s, e, c]), x = (l) => (d) => {
+    const f = l.onBlur;
+    f == null || f(d), E();
+  }, g = (l) => (d) => {
+    const f = l.onFocus;
+    f == null || f(d), p();
+  }, R = (l) => (d) => {
+    const f = l.onMouseEnter;
+    f == null || f(d), p();
+  }, P = (l) => (d) => {
+    const f = l.onMouseLeave;
+    f == null || f(d), E();
+  };
+  return N.useEffect(() => {
+    if (!a && n)
+      return window.addEventListener("focus", E), window.addEventListener("blur", p), () => {
+        window.removeEventListener("focus", E), window.removeEventListener("blur", p);
+      };
+  }, [a, n, E, p]), {
+    getRootProps: (l = {}) => {
+      const d = w({}, H(u), H(l));
+      return w({
+        // ClickAwayListener adds an `onClick` prop which results in the alert not being announced.
+        // See https://github.com/mui/material-ui/issues/29080
+        role: "presentation"
+      }, l, d, {
+        onBlur: x(d),
+        onFocus: g(d),
+        onMouseEnter: R(d),
+        onMouseLeave: P(d)
+      });
+    },
+    onClickAway: m
+  };
+}
+const ne = ["autoHideDuration", "children", "disableWindowBlurListener", "exited", "onBlur", "onClose", "onFocus", "onMouseEnter", "onMouseLeave", "open", "resumeHideDuration", "slotProps", "slots"], oe = () => J({
+  root: ["root"]
+}, Q(ee)), q = /* @__PURE__ */ N.forwardRef(function(s, a) {
+  const {
+    autoHideDuration: r = null,
+    children: n,
+    disableWindowBlurListener: e = !1,
+    exited: o = !0,
+    onClose: i,
+    open: c,
+    resumeHideDuration: m,
+    slotProps: p = {},
+    slots: E = {}
+  } = s, x = j(s, ne), g = oe(), {
+    getRootProps: R,
+    onClickAway: P
+  } = te(w({}, s, {
+    autoHideDuration: r,
+    disableWindowBlurListener: e,
+    onClose: i,
+    open: c,
+    resumeHideDuration: m
+  })), L = s, l = E.root || "div", d = U({
+    elementType: l,
+    getSlotProps: R,
+    externalForwardedProps: x,
+    externalSlotProps: p.root,
+    additionalProps: {
+      ref: a
+    },
+    ownerState: L,
+    className: g.root
+  }), f = U({
+    elementType: B,
+    externalSlotProps: p.clickAwayListener,
+    additionalProps: {
+      onClickAway: P
+    },
+    ownerState: L
+  });
+  return delete f.ownerState, !c && o ? null : /* @__PURE__ */ h(B, w({}, f, {
+    children: /* @__PURE__ */ h(l, w({}, d, {
+      children: n
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (q.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The number of milliseconds to wait before automatically calling the
+   * `onClose` function. `onClose` should then set the state of the `open`
+   * prop to hide the Snackbar. This behavior is disabled by default with
+   * the `null` value.
+   * @default null
+   */
+  autoHideDuration: t.number,
+  /**
+   * @ignore
+   */
+  children: t.node,
+  /**
+   * If `true`, the `autoHideDuration` timer will expire even if the window is not focused.
+   * @default false
+   */
+  disableWindowBlurListener: t.bool,
+  /**
+   * The prop used to handle exited transition and unmount the component.
+   * @default true
+   */
+  exited: t.bool,
+  /**
+   * Callback fired when the component requests to be closed.
+   * Typically `onClose` is used to set state in the parent component,
+   * which is used to control the `Snackbar` `open` prop.
+   * The `reason` parameter can optionally be used to control the response to `onClose`,
+   * for example ignoring `clickaway`.
+   *
+   * @param {React.SyntheticEvent<any> | Event} event The event source of the callback.
+   * @param {string} reason Can be: `"timeout"` (`autoHideDuration` expired), `"clickaway"`, or `"escapeKeyDown"`.
+   */
+  onClose: t.func,
+  /**
+   * If `true`, the component is shown.
+   */
+  open: t.bool,
+  /**
+   * The number of milliseconds to wait before dismissing after user interaction.
+   * If `autoHideDuration` prop isn't specified, it does nothing.
+   * If `autoHideDuration` prop is specified but `resumeHideDuration` isn't,
+   * we default to `autoHideDuration / 2` ms.
+   */
+  resumeHideDuration: t.number,
+  /**
+   * The props used for each slot inside the Snackbar.
+   * @default {}
+   */
+  slotProps: t.shape({
+    clickAwayListener: t.oneOfType([t.func, t.shape({
+      children: t.element.isRequired,
+      disableReactTree: t.bool,
+      mouseEvent: t.oneOf(["onClick", "onMouseDown", "onMouseUp", "onPointerDown", "onPointerUp", !1]),
+      onClickAway: t.func,
+      touchEvent: t.oneOf(["onTouchEnd", "onTouchStart", !1])
+    })]),
+    root: t.oneOfType([t.func, t.object])
+  }),
+  /**
+   * The components used for each slot inside the Snackbar.
+   * Either a string to use a HTML element or a component.
+   * @default {}
+   */
+  slots: t.shape({
+    root: t.elementType
+  })
+});
+function M(u, s) {
+  return M = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, n) {
+    return r.__proto__ = n, r;
+  }, M(u, s);
+}
+function re(u, s) {
+  u.prototype = Object.create(s.prototype), u.prototype.constructor = u, M(u, s);
+}
+const F = {
+  disabled: !1
+};
+var se = process.env.NODE_ENV !== "production" ? t.oneOfType([t.number, t.shape({
+  enter: t.number,
+  exit: t.number,
+  appear: t.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && t.oneOfType([t.string, t.shape({
+  enter: t.string,
+  exit: t.string,
+  active: t.string
+}), t.shape({
+  enter: t.string,
+  enterDone: t.string,
+  enterActive: t.string,
+  exit: t.string,
+  exitDone: t.string,
+  exitActive: t.string
+})]);
+const G = C.createContext(null);
+var ie = function(s) {
+  return s.scrollTop;
+}, S = "unmounted", v = "exited", k = "entering", y = "entered", A = "exiting", b = /* @__PURE__ */ function(u) {
+  re(s, u);
+  function s(r, n) {
+    var e;
+    e = u.call(this, r, n) || this;
+    var o = n, i = o && !o.isMounting ? r.enter : r.appear, c;
+    return e.appearStatus = null, r.in ? i ? (c = v, e.appearStatus = k) : c = y : r.unmountOnExit || r.mountOnEnter ? c = S : c = v, e.state = {
+      status: c
+    }, e.nextCallback = null, e;
+  }
+  s.getDerivedStateFromProps = function(n, e) {
+    var o = n.in;
+    return o && e.status === S ? {
+      status: v
+    } : null;
+  };
+  var a = s.prototype;
+  return a.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, a.componentDidUpdate = function(n) {
+    var e = null;
+    if (n !== this.props) {
+      var o = this.state.status;
+      this.props.in ? o !== k && o !== y && (e = k) : (o === k || o === y) && (e = A);
+    }
+    this.updateStatus(!1, e);
+  }, a.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, a.getTimeouts = function() {
+    var n = this.props.timeout, e, o, i;
+    return e = o = i = n, n != null && typeof n != "number" && (e = n.exit, o = n.enter, i = n.appear !== void 0 ? n.appear : o), {
+      exit: e,
+      enter: o,
+      appear: i
+    };
+  }, a.updateStatus = function(n, e) {
+    if (n === void 0 && (n = !1), e !== null)
+      if (this.cancelNextCallback(), e === k) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var o = this.props.nodeRef ? this.props.nodeRef.current : D.findDOMNode(this);
+          o && ie(o);
+        }
+        this.performEnter(n);
+      } else
+        this.performExit();
+    else
+      this.props.unmountOnExit && this.state.status === v && this.setState({
+        status: S
+      });
+  }, a.performEnter = function(n) {
+    var e = this, o = this.props.enter, i = this.context ? this.context.isMounting : n, c = this.props.nodeRef ? [i] : [D.findDOMNode(this), i], m = c[0], p = c[1], E = this.getTimeouts(), x = i ? E.appear : E.enter;
+    if (!n && !o || F.disabled) {
+      this.safeSetState({
+        status: y
+      }, function() {
+        e.props.onEntered(m);
+      });
+      return;
+    }
+    this.props.onEnter(m, p), this.safeSetState({
+      status: k
+    }, function() {
+      e.props.onEntering(m, p), e.onTransitionEnd(x, function() {
+        e.safeSetState({
+          status: y
+        }, function() {
+          e.props.onEntered(m, p);
+        });
+      });
+    });
+  }, a.performExit = function() {
+    var n = this, e = this.props.exit, o = this.getTimeouts(), i = this.props.nodeRef ? void 0 : D.findDOMNode(this);
+    if (!e || F.disabled) {
+      this.safeSetState({
+        status: v
+      }, function() {
+        n.props.onExited(i);
+      });
+      return;
+    }
+    this.props.onExit(i), this.safeSetState({
+      status: A
+    }, function() {
+      n.props.onExiting(i), n.onTransitionEnd(o.exit, function() {
+        n.safeSetState({
+          status: v
+        }, function() {
+          n.props.onExited(i);
+        });
+      });
+    });
+  }, a.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, a.safeSetState = function(n, e) {
+    e = this.setNextCallback(e), this.setState(n, e);
+  }, a.setNextCallback = function(n) {
+    var e = this, o = !0;
+    return this.nextCallback = function(i) {
+      o && (o = !1, e.nextCallback = null, n(i));
+    }, this.nextCallback.cancel = function() {
+      o = !1;
+    }, this.nextCallback;
+  }, a.onTransitionEnd = function(n, e) {
+    this.setNextCallback(e);
+    var o = this.props.nodeRef ? this.props.nodeRef.current : D.findDOMNode(this), i = n == null && !this.props.addEndListener;
+    if (!o || i) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var c = this.props.nodeRef ? [this.nextCallback] : [o, this.nextCallback], m = c[0], p = c[1];
+      this.props.addEndListener(m, p);
+    }
+    n != null && setTimeout(this.nextCallback, n);
+  }, a.render = function() {
+    var n = this.state.status;
+    if (n === S)
+      return null;
+    var e = this.props, o = e.children;
+    e.in, e.mountOnEnter, e.unmountOnExit, e.appear, e.enter, e.exit, e.timeout, e.addEndListener, e.onEnter, e.onEntering, e.onEntered, e.onExit, e.onExiting, e.onExited, e.nodeRef;
+    var i = j(e, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ C.createElement(G.Provider, {
+        value: null
+      }, typeof o == "function" ? o(n, i) : C.cloneElement(C.Children.only(o), i))
+    );
+  }, s;
+}(C.Component);
+b.contextType = G;
+b.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: t.shape({
+    current: typeof Element > "u" ? t.any : function(u, s, a, r, n, e) {
+      var o = u[s];
+      return t.instanceOf(o && "ownerDocument" in o ? o.ownerDocument.defaultView.Element : Element)(u, s, a, r, n, e);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: t.oneOfType([t.func.isRequired, t.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: t.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: t.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: t.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: t.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: t.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: t.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(s) {
+    var a = se;
+    s.addEndListener || (a = a.isRequired);
+    for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), e = 1; e < r; e++)
+      n[e - 1] = arguments[e];
+    return a.apply(void 0, [s].concat(n));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: t.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: t.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: t.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: t.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: t.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: t.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: t.func
+} : {};
+function _() {
+}
+b.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: _,
+  onEntering: _,
+  onEntered: _,
+  onExit: _,
+  onExiting: _,
+  onExited: _
+};
+b.UNMOUNTED = S;
+b.EXITED = v;
+b.ENTERING = k;
+b.ENTERED = y;
+b.EXITING = A;
+const ae = "_snackbar_kt3bd_1", ue = "_bottomToTop_kt3bd_1", T = {
+  snackbar: ae,
+  "snackbar__snackbar-el-wrapper": "_snackbar__snackbar-el-wrapper_kt3bd_14",
+  "snackbar--content": "_snackbar--content_kt3bd_19",
+  "snackbar--success": "_snackbar--success_kt3bd_29",
+  "snackbar--error": "_snackbar--error_kt3bd_32",
+  "snackbar--attention": "_snackbar--attention_kt3bd_35",
+  "snackbar--message": "_snackbar--message_kt3bd_38",
+  "snackbar--action": "_snackbar--action_kt3bd_46",
+  bottomToTop: ue
+}, ve = ({
+  snackbarMessage: u,
+  color: s,
+  autoHideDuration: a = 5e3,
+  open: r = !0,
+  onClose: n,
+  classNameWrapper: e,
+  "data-testid": o
+}) => {
+  const [i, c] = V(!0), m = X(null), p = {
+    entering: "translateY(0)",
+    entered: "translateY(0)",
+    exiting: "translateY(80px)",
+    exited: "translateY(80px)",
+    unmounted: "translateY(80px)"
+  }, E = () => {
+    c(!1);
+  }, x = () => {
+    c(!0);
+  };
+  return /* @__PURE__ */ h("div", { className: O(T.snackbar, e), children: /* @__PURE__ */ h(
+    q,
+    {
+      autoHideDuration: a,
+      open: r,
+      onClose: n,
+      exited: i,
+      className: O(T["snackbar__snackbar-el-wrapper"]),
+      children: /* @__PURE__ */ h(
+        b,
+        {
+          timeout: { enter: 400, exit: 400 },
+          in: r,
+          appear: !0,
+          unmountOnExit: !0,
+          onEnter: E,
+          onExited: x,
+          nodeRef: m,
+          children: (g) => /* @__PURE__ */ Y(
+            "div",
+            {
+              className: O(T["snackbar--content"], T[`snackbar--${s}`]),
+              style: {
+                transform: p[g],
+                transition: "transform 300ms ease"
+              },
+              ref: m,
+              "data-testid": o,
+              children: [
+                /* @__PURE__ */ h("div", { className: O(T["snackbar--message"]), children: /* @__PURE__ */ h("p", { children: u }) }),
+                /* @__PURE__ */ h("div", { className: O(T["snackbar--action"]), children: /* @__PURE__ */ h("a", { onClick: n, children: /* @__PURE__ */ h(K, { icon: "xmark", color: "var(--white-100)", size: "1.5rem" }) }) })
+              ]
+            }
+          )
+        }
+      )
+    }
+  ) });
+};
+export {
+  ve as Snackbar
+};

package/dist/components/SortTooltip/SortTooltip.d.ts

@@ -0,0 +1,26 @@
+export type SortType = 'ASC' | 'DESC';
+type SortCommonProps = {
+    className?: string;
+    'data-testid'?: string;
+};
+export type SortTranslationsByKeys = {
+    asc: string;
+    desc: string;
+};
+type SortLanguages = 'pt' | 'en';
+type SortTranslations = {
+    t?: SortTranslationsByKeys;
+    language?: SortLanguages;
+};
+type SortTooltipProps = {
+    onSort: (order: SortType) => void;
+    onClose: () => void;
+    sortType?: SortType;
+    show?: boolean;
+    anchorRef?: HTMLElement | null | undefined;
+} & SortCommonProps & SortTranslations;
+export declare const sortTooltipDefaultTranslations: {
+    [key in SortLanguages]: SortTranslationsByKeys;
+};
+declare const SortTooltip: ({ show, onSort, sortType, onClose, t, language, className, ...rest }: SortTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export { SortTooltip };