linear-react-components-ui 1.1.26-beta.7 → 1.1.26-beta.9

package/lib/inputs/select/multiple/index.js

@@ -0,0 +1,126 @@
+import { j as C } from "../../../chunks/jsx-runtime.D1SHvdVE.js";
+import { useState as u, useRef as R, useEffect as F } from "react";
+import { _ as I } from "../../../chunks/lodash.CIAK_hAg.js";
+import fe from "../Dropdown.js";
+import me from "../ActionButtons.js";
+import he from "./Selecteds.js";
+import { keyCodes as p } from "../../../internals/constants.js";
+import Ce from "../../base/InputTextBase.js";
+import { getFilteredMultipleDataCombo as J } from "../helper.js";
+import pe from "../../../hint/index.js";
+import { v as ge } from "../../../chunks/v1.Ds1rkxUj.js";
+const Be = (n) => {
+  const {
+    idKey: d,
+    dataSource: i = [],
+    handlerClear: Q,
+    value: g = [],
+    remoteSearch: L = !1,
+    descriptionKey: f,
+    showClearButton: X,
+    rightElements: Y = [],
+    hint: j,
+    hintPosition: Z = "below",
+    customClassForLabel: V,
+    customClassForWrapper: _,
+    customClassForInputContent: ee,
+    customClassForSideButtons: te
+  } = n, [r, D] = u(i), [s, S] = u([]), [w, m] = u(), [b, y] = u([]), [O, c] = u(!1), [K, W] = u(0), [ne, oe] = u(!1), [v, re] = u(), [ie, le] = u([]), A = `select-component${ge()}`, T = R(null), h = R(null), l = R(null), E = R(null), a = R(null), N = typeof f == "string", se = ["item", "menubutton", "filterinput", "filtercontainer", "label", "actionbutton"], P = () => {
+    l.current && W(l.current.clientWidth);
+  }, $ = (e) => {
+    const {
+      target: t
+    } = e;
+    !se.includes(t.className) && t !== l.current && l.current && !l.current.contains(t) && h.current && !h.current.contains(t) && c(!1);
+  }, M = (e) => {
+    const t = e.target, o = h.current?.parentElement?.id || "", ae = !!document.getElementById(o)?.contains(t);
+    oe(ae);
+  }, z = () => {
+    m(void 0), S([]), n.onSelect && n.onSelect();
+  }, U = (e) => {
+    let t = null;
+    if (L)
+      n.onSearch && n.onSearch(e), c(!0), y([e]);
+    else {
+      let o = i;
+      e.length > 0 && (o = J({
+        inputText: [e],
+        dataSource: i,
+        descriptionKey: f,
+        currents: s
+      })), o && o.length > 0 && (t = o[0]), D(o), c(!0), t && m(t), y([e]);
+    }
+  }, x = () => {
+    const e = l.current ? l.current.clientWidth : K;
+    c(!0), W(e);
+  }, q = (e) => {
+    if (e === null) return;
+    const t = [...s, e];
+    S(t), D(i), y([]), a && a.current && a.current.focus(), n.onSelect && m(n.onSelect(t.map((o) => o[d]))), h.current?.focus();
+  }, ce = (e) => {
+    if (s) {
+      const t = s.filter((o) => o[d] !== e);
+      S(t), a && a.current && a.current.focus(), c(!1), n.onSelect && m(n.onSelect(t.map((o) => o[d]))), h.current?.focus();
+    }
+  }, ue = () => {
+    c((e) => !e), l.current && W(l.current.clientWidth);
+  }, H = (e) => {
+    n.onBlur && n.onBlur(e), ne || (c(!1), D(i));
+  }, G = (e) => {
+    if (e.keyCode)
+      if (e.keyCode === p.ENTER && w && O)
+        e.preventDefault?.(), s.some((t) => t[d] === w[d]) || (e.preventDefault?.(), q(w));
+      else if ([p.ARROW_UP, p.ARROW_DOWN].includes(e.keyCode)) {
+        O || c(!0);
+        let t = r ? r.findIndex((o) => o === w) : 0;
+        e.keyCode === p.ARROW_DOWN ? t = r && t === r.length - 1 ? 0 : t + 1 : t = r && t === 0 ? r.length - 1 : t - 1, r && r.length && (N && r[t][f] ? y(r[t][f]) : N || y([f(r[t])])), r && m(r[t]);
+      } else if (e.keyCode === p.BACKSPACE) {
+        if (b.length === 0) {
+          const t = I.dropRight(s);
+          S(t), n.onSelect && n.onSelect(t.map((o) => o[d]));
+        }
+      } else e.keyCode === p.TAB && c(!1);
+  }, de = (e) => {
+    re(e);
+  }, B = () => n.disabled || v && (v.disabled || v.hideContent), k = () => n.readOnly || v && v.readOnly;
+  return F(() => (window.addEventListener("resize", P), document.addEventListener("click", $), document.addEventListener("mousemove", M), Q && z(), () => {
+    window.removeEventListener("resize", P), document.removeEventListener("click", $), document.removeEventListener("mousemove", M);
+  }), []), F(() => {
+    if (n.gridLayout) {
+      const e = document.querySelector(`#${A}>.-withinput.grid-container`);
+      E.current !== e && e && (E.current = e);
+    }
+  }, []), F(() => {
+    if (g.length > 0 && g !== ie && i.length > 0) {
+      const e = i.filter((t) => g.includes(t[d]));
+      le(g), S(e);
+    }
+  }, [i.length, g.length]), F(() => {
+    if (!I.isEqual(i, r)) {
+      const e = L ? i : J({
+        currents: s,
+        dataSource: i,
+        descriptionKey: f,
+        inputText: b
+      });
+      D(e), m(e.length > 0 ? r[0] : null);
+    }
+  }, [i]), /* @__PURE__ */ C.jsxs("span", { id: A, ref: T, className: "select-component", children: [
+    /* @__PURE__ */ C.jsx(Ce, { ...n, inputRef: (e) => {
+      n.inputRef && (I.isFunction(n.inputRef) ? n.inputRef(e) : n.inputRef.current = e), a.current = e;
+    }, autoComplete: "off", value: b.toString(), readOnly: k(), onFocus: () => {
+      x();
+    }, onBlur: (e) => {
+      H(e);
+    }, onChange: (e) => {
+      e && U(e.target.value);
+    }, onClick: x, onKeyDown: G, customClassForLabel: V, customClassForWrapper: `selectwrapper ${(n.readOnly || B() || k()) && " -undigitable"} ${_}`, customClassForInputContent: `multiselect ${ee}`, inputBaseRef: (e) => {
+      l.current = e;
+    }, handlerSetOnDenied: de, rightElements: [...Y, /* @__PURE__ */ C.jsx(me, { showClearButton: X, disabled: B() || k(), dropDownOpened: O, handlerClear: () => B() ? null : z(), handlerOpenClose: ue, customClassForSideButtons: te }, "action-buttons-multiselect")], children: /* @__PURE__ */ C.jsx(he, { ...n, currents: s, handlerOnUnselect: ce }) }),
+    O && /* @__PURE__ */ C.jsx(fe, { ...n, selected: w, selectFieldRef: T, dropdownRef: h, gridWrapperStyle: n.gridLayout && E.current ? window.getComputedStyle(E.current) : void 0, handleOnSelect: q, handleOnFilter: U, handleOnKeydown: G, handleOnBlur: () => H, handleOnFocus: x, opened: O, dataCombo: r, currents: s, dropdownWidth: K || 0 }),
+    /* @__PURE__ */ C.jsx(pe, { visible: !!j && Z === "below", customClass: "hint", description: j })
+  ] });
+};
+export {
+  Be as default
+};

package/lib/inputs/select/select.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/inputs/select/simple/index.d.ts

@@ -0,0 +1,3 @@
+import { ISimpleSelectProps } from '../types';
+declare const SimpleSelect: (props: ISimpleSelectProps) => import("react/jsx-runtime").JSX.Element;
+export default SimpleSelect;

package/lib/inputs/select/simple/index.js

@@ -0,0 +1,156 @@
+import { j as W } from "../../../chunks/jsx-runtime.D1SHvdVE.js";
+import { useState as m, useRef as R, useEffect as F } from "react";
+import { _ as Y } from "../../../chunks/lodash.CIAK_hAg.js";
+import we from "../Dropdown.js";
+import ye from "../ActionButtons.js";
+import { keyCodes as x } from "../../../internals/constants.js";
+import { getFilteredSimpleDataCombo as Z } from "../helper.js";
+import Se from "../../base/InputTextBase.js";
+import { v as Re } from "../../../chunks/v1.Ds1rkxUj.js";
+const Le = (i) => {
+  const {
+    value: C,
+    descriptionKey: t,
+    dataSource: D = [],
+    gridLayout: B,
+    onSearch: K,
+    disabled: ee,
+    readOnly: ne,
+    openDropdownOnFocus: te = !0,
+    selectFirstOnEnter: oe = !1,
+    idKey: g,
+    remoteSearch: k = !1,
+    name: N = "",
+    undigitable: I,
+    searchOnDropdown: _ = !1,
+    allOptions: a = void 0,
+    showClearButton: ie = !1,
+    searchNotFoundText: se,
+    rightElements: re = [],
+    customClassForWrapper: le,
+    customClassForInputContent: ce,
+    customClassForLabel: ue,
+    customClassForSideButtons: ae
+  } = i, r = typeof t == "string", o = a ? [{
+    [g]: a.idValue,
+    [r ? t : t(a.label)]: a.label
+  }, ...D] : D, [s, v] = m(o), [c, p] = m(null), [O, u] = m(""), [y, d] = m(!1), [de, L] = m(0), [fe, me] = m(!1), [S, pe] = m(), [$, A] = m(!1), E = R(null), P = `select-component-${N}-${Re()}`, z = R(null), l = R(null), b = R(null), h = R(null), V = () => {
+    l.current && L(l.current.clientWidth);
+  }, q = (e) => {
+    const {
+      target: n
+    } = e;
+    n !== l.current && !l.current?.contains(n) && !E.current?.contains(n) && d(!1);
+  }, M = (e) => {
+    const n = e.target, f = E.current?.parentElement?.id || "", Oe = !!document.getElementById(f)?.contains(n);
+    me(Oe);
+  }, J = (e) => ({
+    target: {
+      value: e ? e[g] : void 0,
+      name: N
+    }
+  }), w = (e) => {
+    if (i.onChange) {
+      const n = J(e);
+      i.onChange(n);
+    }
+  }, U = (e) => {
+    let n = null;
+    if (k)
+      K && K(e);
+    else {
+      const f = Z({
+        inputText: e,
+        descriptionKey: t,
+        dataSource: o
+      });
+      f && f.length > 0 && (n = f[0], p(n)), v(f);
+    }
+    d(!0), u(e), n && (r && e === n[t] || !r && e === t(n)) && w(n);
+  }, G = (e) => {
+    e && (p(e), u(r ? e[t] : t(e)), new Promise((n) => {
+      n(w(e));
+    }).finally(() => {
+      h && h.current && h.current.focus(), d(!1);
+    }), E.current?.focus());
+  }, he = () => {
+    d((e) => !e), l.current && L(l.current.clientWidth);
+  }, T = () => {
+    if (te && d(!0), l) {
+      const e = l.current ? l.current.clientWidth : 0;
+      L(e);
+    }
+  }, H = () => {
+    if (i.onBlur) {
+      const e = J(c);
+      i.onBlur(e), (c && r && O !== c[t] || !r && O !== t(c)) && (p(null), u(O), new Promise((n) => {
+        n(w(null));
+      }).finally(() => {
+        w();
+      }));
+    }
+    fe || (d(!1), A(!1), v(o));
+  }, Q = (e) => {
+    if (e.keyCode) {
+      if (e.keyCode === x.ENTER && c && y)
+        e.preventDefault?.(), G(c);
+      else if ([x.ARROW_UP, x.ARROW_DOWN].includes(e.keyCode)) {
+        y || d(!0);
+        let n = s.length > 0 ? s.findIndex((f) => c && f[g] === c[g]) : 0;
+        e.keyCode === x.ARROW_DOWN ? n = s && n === s.length - 1 ? 0 : n + 1 : n = s && n === 0 ? s?.length - 1 : n - 1, p(s[n]), r && u(s[n][t]), r || u(t(s[n]));
+      }
+    }
+    $ || A(!0);
+  }, Ce = () => {
+    new Promise((e) => {
+      e(w(null));
+    }).finally(() => {
+      p(null), u(""), w(), h && h.current && h.current.focus(), d(!1);
+    });
+  }, ge = (e) => {
+    pe(e);
+  }, X = () => ee || S && (S.disabled || S.hideContent), j = () => ne || S && S.readOnly;
+  return F(() => (window.addEventListener("resize", V), document.addEventListener("click", q), document.addEventListener("mousemove", M), () => {
+    window.removeEventListener("resize", V), document.removeEventListener("click", q), document.removeEventListener("mousemove", M);
+  }), []), F(() => {
+    if (B) {
+      const e = document.querySelector(`#${P}>.-withinput.grid-container`);
+      b.current !== e && e && (b.current = e);
+    }
+  }, [B]), F(() => {
+    if (o.length > 0) {
+      let e = null;
+      C || C === 0 ? e = o.find((n) => (C || C === 0) && n[g]?.toString().toLowerCase() === C?.toString().toLowerCase()) : o.length > 0 && oe && (e = o[0]), p(e), u(r ? e ? e[t] : "" : e ? t(e) : "");
+    }
+  }, [o.length, C]), F(() => {
+    if (!Y.isEqual(s, o)) {
+      const e = I || k || !$ ? o : Z({
+        inputText: O,
+        dataSource: o,
+        descriptionKey: t
+      });
+      if (v(e), o.length > 0 && k) {
+        const n = o[0];
+        p(n);
+      }
+    }
+    a && v([{
+      [g]: a.idValue,
+      [r ? t : t(a.label)]: a.label
+    }, ...D]);
+  }, [JSON.stringify(o)]), /* @__PURE__ */ W.jsxs("span", { id: P, ref: z, className: "select-component", children: [
+    /* @__PURE__ */ W.jsx(Se, { ...i, inputRef: (e) => {
+      i.inputRef && (Y.isFunction(i.inputRef) ? i.inputRef(e) : i.inputRef.current = e), h.current = e;
+    }, autoComplete: "off", readOnly: I || j(), value: O, onFocus: T, onBlur: H, onChange: (e) => {
+      e && U(e.target.value);
+    }, onClick: T, onKeyDown: Q, customClassForLabel: ue, customClassForWrapper: `selectwrapper ${(I || _ || j()) && " -undigitable"} ${le}`, customClassForInputContent: `multiselect ${ce}`, inputBaseRef: (e) => {
+      l.current = e;
+    }, handlerSetOnDenied: (e) => ge(e), rightElements: [...re, /* @__PURE__ */ W.jsx(ye, { disabled: X() || j(), showClearButton: ie, dropDownOpened: y, handlerClear: () => X() ? null : Ce(), handlerOpenClose: he, customClassForSideButtons: ae }, "action-buttons-simpleselect")] }),
+    y && /* @__PURE__ */ W.jsx(we, { ...i, opened: y, selected: c, inputValue: O, selectFieldRef: z, dropdownRef: E, searchOnDropdown: _, gridWrapperStyle: B && b.current ? window.getComputedStyle(b.current) : void 0, handleOnSelect: (e) => {
+      e && G(e);
+    }, handleOnFilter: (e) => U(e), handleOnKeydown: Q, handleOnBlur: () => H, handleOnFocus: T, dataCombo: s, dropdownWidth: de || 0, searchNotFoundText: se })
+  ] });
+};
+export {
+  Le as default
+};

package/lib/inputs/select/types.d.ts

@@ -0,0 +1,117 @@
+import { TextAlign } from 'src/lib/@types/Align';
+import { JSX, MutableRefObject } from 'react';
+import { DataCombo } from '../../@types/DataCombo';
+import { PermissionAttr } from '../../@types/PermissionAttr';
+import { CustomInputEvent } from '../base/types';
+export type AllOptions = {
+    idValue?: number | null;
+    label: string;
+};
+export type DescriptionKey = string | ((dataSelected: DataCombo) => string);
+export interface ISimpleSelectProps {
+    idKey: string;
+    descriptionKey: DescriptionKey;
+    dataSource?: DataCombo[];
+    id?: string;
+    label?: string;
+    placeHolder?: string;
+    hint?: string;
+    value?: string | number | boolean | number[];
+    textAlign?: TextAlign;
+    errorMessages?: string[];
+    showClearButton?: boolean;
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    onChange?: (e: CustomInputEvent) => void;
+    undigitable?: boolean;
+    name?: string;
+    selectFirstOnEnter?: boolean;
+    openDropdownOnFocus?: boolean;
+    onSearch?: (value: string) => void;
+    remoteSearch?: boolean;
+    onBlur?: (e: CustomInputEvent) => void;
+    onClick?: () => void;
+    disabled?: boolean;
+    readOnly?: boolean;
+    gridLayout?: string;
+    inputText?: string;
+    striped?: boolean | false;
+    permissionAttr?: PermissionAttr;
+    maxLength?: number;
+    dropdownMaxHeight?: number;
+    multiple?: boolean;
+    rounded?: boolean;
+    required?: boolean;
+    autoFocus?: boolean;
+    onFocus?: () => void;
+    allOptions?: AllOptions;
+    inputRef?: MutableRefObject<HTMLInputElement | HTMLTextAreaElement | null> | ((ref: HTMLInputElement | HTMLTextAreaElement | null) => void);
+    customClassForWrapper?: string;
+    customClassForInputContent?: string;
+    customClassForLabel?: string;
+    customClassForSideButtons?: string;
+    rightElements?: JSX.Element[];
+    hintPosition?: 'below' | 'onLabelRight';
+    themePopover?: 'light' | 'dark';
+    popoverAlign?: 'right' | 'left';
+}
+export interface ISelectFieldProps extends Omit<ISimpleSelectProps, 'idKey' | 'value' | 'descriptionKey'> {
+    multiple?: boolean;
+    gridLayout?: string;
+    descriptionKey?: DescriptionKey;
+    idKey?: string;
+    dataSource?: DataCombo[];
+    value?: number | number[] | string | string[];
+    showClearButton?: boolean;
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    inputText?: string | '';
+    striped?: boolean | false;
+    readOnly?: boolean;
+    undigitable?: boolean;
+    rounded?: boolean;
+    selectFirstOnEnter?: boolean;
+    remoteSearch?: boolean;
+    openDropdownOnFocus?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    onSelect?: (data?: string | string[]) => DataCombo;
+}
+export interface IMultipleSelectProps extends Omit<ISimpleSelectProps, 'idKey' | 'value' | 'descriptionKey'> {
+    descriptionKey: DescriptionKey;
+    idKey: string;
+    dataSource: DataCombo[];
+    searchNotFoundText?: string;
+    searchOnDropdown?: boolean;
+    value?: number[] | string[];
+    showClearButton?: boolean;
+    readOnly?: boolean;
+    onSearch?: (value: string) => void;
+    onSelect?: (data?: string | string[]) => DataCombo;
+    remoteSearch?: boolean;
+    onBlur?: (e: CustomInputEvent) => void;
+    handlerClear?: () => void;
+    disabled?: boolean;
+    gridLayout?: string;
+    hintPosition?: 'below' | 'onLabelRight';
+    themePopover?: 'light' | 'dark';
+    popoverAlign?: 'right' | 'left';
+}
+export interface ISelectedsMultipleProps {
+    idKey: string;
+    descriptionKey: DescriptionKey;
+    currents: DataCombo[];
+    handlerOnUnselect: (id: string) => void;
+}
+export interface GetFilteredParams {
+    dataSource: DataCombo[];
+    descriptionKey: DescriptionKey;
+    currents: DataCombo[];
+}
+export interface GetSimpleFilteredParams extends GetFilteredParams {
+    inputText: number | string;
+}
+export interface GetMultipleFilteredParams extends GetFilteredParams {
+    inputText: number[] | string[];
+}

package/lib/inputs/text/index.d.ts

@@ -0,0 +1,3 @@
+import { ITextField } from './types';
+declare const TextField: (props: ITextField) => import("react/jsx-runtime").JSX.Element;
+export default TextField;

package/lib/inputs/text/index.js

@@ -0,0 +1,11 @@
+import { j as r } from "../../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as m } from "../../chunks/compiler-runtime.Cu50tn6L.js";
+import s from "../base/InputTextBase.js";
+const a = (o) => {
+  const t = m.c(2);
+  let e;
+  return t[0] !== o ? (e = /* @__PURE__ */ r.jsx(s, { ...o }), t[0] = o, t[1] = e) : e = t[1], e;
+};
+export {
+  a as default
+};

package/lib/inputs/text/textfield.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/inputs/text/types.d.ts

@@ -0,0 +1,21 @@
+import { JSX } from 'react';
+import { Period } from '../../@types/Period';
+import { PermissionAttr } from '../../@types/PermissionAttr';
+import { CustomInputEvent, IBaseProps } from '../base/types';
+import { WithTooltipProps } from '../../internals/types';
+type CommonProperties = Pick<WithTooltipProps, 'tooltip' | 'tooltipPosition' | 'tooltipWidth'>;
+export interface ITextField extends IBaseProps, CommonProperties {
+    value?: string | string[];
+    required?: boolean;
+    name?: string;
+    label?: string | string[];
+    onChange?: (e?: CustomInputEvent, maskValue?: string, date?: {
+        initial: string;
+        final: string;
+    }, period?: Period) => void;
+    leftElements?: JSX.Element | JSX.Element[];
+    rightElements?: JSX.Element | JSX.Element[];
+    permissionAttr?: PermissionAttr;
+    gridLayout?: string;
+}
+export {};

package/lib/inputs/textarea/index.d.ts

@@ -0,0 +1,3 @@
+import { ITextAreaProps } from './types';
+declare const TextArea: (props: ITextAreaProps) => import("react/jsx-runtime").JSX.Element;
+export default TextArea;

package/lib/inputs/textarea/index.js

@@ -0,0 +1,16 @@
+import { j as i } from "../../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as x } from "../../chunks/compiler-runtime.Cu50tn6L.js";
+import l from "../base/InputTextBase.js";
+const j = (e) => {
+  const t = x.c(6), {
+    rows: o,
+    cols: r,
+    customClass: n,
+    type: m
+  } = e, a = m === void 0 ? "textarea" : m, c = `textarea-container ${n}`;
+  let s;
+  return t[0] !== r || t[1] !== e || t[2] !== o || t[3] !== c || t[4] !== a ? (s = /* @__PURE__ */ i.jsx(l, { ...e, rows: o, type: a, cols: r, customClass: c }), t[0] = r, t[1] = e, t[2] = o, t[3] = c, t[4] = a, t[5] = s) : s = t[5], s;
+};
+export {
+  j as default
+};

package/lib/inputs/textarea/textarea.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/inputs/textarea/types.d.ts

@@ -0,0 +1,7 @@
+import { IBaseProps } from '../base/types';
+export interface ITextAreaProps extends IBaseProps {
+    rows?: number;
+    cols?: number;
+    customClass?: string;
+    type?: string;
+}

package/lib/inputs/types.d.ts

@@ -0,0 +1,151 @@
+import { CSSProperties, JSX, KeyboardEvent, MouseEvent, MutableRefObject, ReactElement, ReactNode } from 'react';
+import { OnDenied, PermissionAttr } from '../@types/PermissionAttr';
+import { DataCombo } from '../@types/DataCombo';
+import { CustomInputEvent, IBaseProps } from './base/types';
+import { IDrawerProps } from '../drawer/types';
+import { TextAlign } from '../@types/Align';
+type DescriptionKey = string | ((dataSelected: DataCombo) => string);
+export interface IAdvancedFilterProps extends Omit<IDrawerProps, 'content'> {
+    onStateChange?: (value?: boolean) => void;
+    headerTitle?: string;
+    content?: ReactNode | ReactNode[];
+}
+export interface ISearchProps extends IBaseProps {
+    resetButton?: boolean;
+    onReset?: (event?: CustomInputEvent) => void;
+    onChange?: (event?: CustomInputEvent) => void;
+    onClick?: (event: MouseEvent<Element>) => void;
+    textAlign?: TextAlign;
+    disabled?: boolean;
+    readOnly?: boolean;
+    value?: string;
+    placeHolder?: string;
+    permissionAttr?: PermissionAttr;
+    advancedFilterProps?: IAdvancedFilterProps;
+    rounded?: boolean;
+    inputRef?: MutableRefObject<HTMLInputElement | HTMLTextAreaElement | null>;
+    style?: CSSProperties;
+}
+export interface IDropdownProps {
+    children: ReactNode | ReactNode[];
+    dropdownRef: (el: HTMLDivElement) => void;
+    topPosition: number | string;
+    leftPosition: number | string;
+    width: number | string;
+}
+export interface IInputHOCProps {
+    value?: string | string[];
+    required?: boolean;
+    gridLayout?: string;
+    visible?: boolean;
+    rows?: number;
+    cols?: number;
+    type?: string;
+}
+export interface IMaskHOCProps {
+    label?: string;
+    value?: string;
+    unmask?: boolean;
+    name?: string;
+    commit?: () => void;
+    onChange?: (event: CustomInputEvent, maskValue?: string, date?: string) => void;
+    onFocus?: (e: CustomInputEvent) => void;
+    onComplete?: (e: CustomInputEvent, maskValue?: string, date?: string) => void;
+    inputRef?: MutableRefObject<HTMLInputElement | HTMLTextAreaElement | null> | ((ref: HTMLInputElement | HTMLTextAreaElement | null) => void);
+    placeholderChar?: string;
+    lazy?: boolean;
+    definitions?: any;
+    groups?: object;
+    pattern?: string;
+    format?: () => void;
+    parse?: () => void;
+    radix?: string;
+    thousandsSeparator?: string;
+    mapToRadix?: string[];
+    scale?: number;
+    signed?: boolean;
+    normalizeZeros?: boolean;
+    padFractionalZeros?: boolean;
+    min?: number;
+    max?: number;
+    dispatch?: () => void;
+    permissionAttr?: PermissionAttr;
+    handlerSetOnDenied?: (onDeniedValue: OnDenied) => void;
+    isNumeric?: boolean;
+    required?: boolean;
+    onKeyDown?: (e: CustomInputEvent | KeyboardEvent<Element>) => void;
+    rightElements?: JSX.Element | JSX.Element[];
+    labelUppercase?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    gridLayout?: string;
+    placeHolder?: string;
+    customClass?: string;
+    customClassForInputContent?: string;
+    customClassForLabel?: string;
+    textAlign?: TextAlign;
+    onBlur?: (e: CustomInputEvent) => void;
+    leftElements?: JSX.Element | JSX.Element[];
+    rounded?: boolean;
+    errorMessages?: string[];
+    skeletonize?: boolean;
+    mask?: any;
+    isDateField?: boolean;
+    autoCompleteMask?: 'left' | 'right';
+}
+export interface IDropdownSelectProps {
+    idKey: string;
+    descriptionKey: DescriptionKey;
+    dropdownWidth: number;
+    showClearButton?: boolean;
+    handleOnSelect: (item?: DataCombo) => void;
+    handleOnFilter: (value: string) => void;
+    handleOnKeydown: (e: CustomInputEvent | KeyboardEvent) => void;
+    handleOnBlur: (item: DataCombo) => void;
+    handleOnFocus: () => void;
+    handlerSelecionadoAgora?: (bool: boolean) => void;
+    opened: boolean;
+    dropdownRef: MutableRefObject<HTMLDivElement | null>;
+    dataCombo: DataCombo[];
+    searchOnDropdown?: boolean;
+    searchNotFoundText?: string;
+    imgSrcKey?: string;
+    selected?: {
+        [key: string]: number;
+    };
+    currents?: DataCombo[];
+    imageAlign?: 'left' | 'right';
+    striped?: boolean;
+    gridWrapperStyle?: {
+        paddingLeft: string;
+        paddingRight: string;
+    };
+    selectFieldRef?: MutableRefObject<HTMLInputElement | null>;
+    dropdownMaxHeight?: number;
+    inputValue?: string;
+    align?: 'left' | 'right';
+}
+export interface IActionButtonsSelectProps {
+    handlerClear: () => void;
+    handlerOpenClose: () => void;
+    dropDownOpened: boolean;
+    showClearButton?: boolean;
+    disabled?: boolean;
+    customClassForSideButtons?: string;
+}
+export interface IButtonsProps {
+    onClick?: (e: MouseEvent<HTMLButtonElement>) => void;
+    icon: ReactElement;
+    key: string;
+    boxShadow: boolean;
+    readOnly?: boolean;
+    style: CSSProperties;
+    transparent: boolean;
+    disabled?: boolean;
+}
+export interface ErrorProps {
+    customClass?: string;
+    style?: React.CSSProperties;
+    messages?: string | string[];
+}
+export {};

package/lib/internals/colorStyles.d.ts

@@ -0,0 +1,8 @@
+declare const ColorStyles: {
+    PRIMARY: string;
+    SUCCESS: string;
+    DANGER: string;
+    INFO: string;
+    WARNING: string;
+};
+export default ColorStyles;

package/lib/internals/colorStyles.js

@@ -0,0 +1,10 @@
+const r = {
+  PRIMARY: "primary",
+  SUCCESS: "success",
+  DANGER: "danger",
+  INFO: "info",
+  WARNING: "warning"
+};
+export {
+  r as default
+};

package/lib/internals/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const keyCodes: {
+    TAB: number;
+    ENTER: number;
+    ARROW_UP: number;
+    ARROW_DOWN: number;
+    BACKSPACE: number;
+    F: number;
+};
+export declare const PARA_ENGANAR_O_ESLINT_JA_QUE_TENHO_SO_UMA_CONSTANTE = 1;

package/lib/internals/constants.js

@@ -0,0 +1,12 @@
+const A = {
+  TAB: 9,
+  ENTER: 13,
+  ARROW_UP: 38,
+  ARROW_DOWN: 40,
+  BACKSPACE: 8,
+  F: 70
+}, _ = 1;
+export {
+  _ as PARA_ENGANAR_O_ESLINT_JA_QUE_TENHO_SO_UMA_CONSTANTE,
+  A as keyCodes
+};