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

package/lib/form/index.js

@@ -0,0 +1,150 @@
+import { j as x } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import { useState as m, useContext as ar, useRef as U, useCallback as q, useEffect as F, Fragment as ur } from "react";
+import { _ as f } from "../chunks/lodash.CIAK_hAg.js";
+import { changeValue as B, FormContext as mr } from "./helpers.js";
+import { default as Ar } from "./Field.js";
+import { default as Qr } from "./FieldNumber.js";
+import { default as Dr } from "./FieldArray.js";
+import { default as Ur } from "./FieldPeriod.js";
+import "../chunks/index.aw0XaUkg.js";
+import "../chunks/compiler-runtime.Cu50tn6L.js";
+import "../buttons/DefaultButton.js";
+import "../icons/index.js";
+import '../assets/button.css';import '../assets/index13.css';/* empty css                        */
+import dr from "../dialog/Question.js";
+import { FormSecurityContext as pr } from "./withFormSecurity.js";
+import { v as Fr } from "../chunks/v1.Ds1rkxUj.js";
+const Cr = ({
+  submitOnPressEnterKey: g = !0,
+  dataSource: d,
+  securityBeforeUnload: j,
+  handlerReset: k,
+  handlerSubmit: L,
+  handlerValidates: w,
+  style: M,
+  customClass: z,
+  securityTitle: $,
+  securityText: G,
+  securityData: C,
+  onDataChange: u,
+  onValidateForm: p,
+  externalFieldErrors: H,
+  onSubmit: T,
+  skeletonize: W,
+  disabled: V,
+  children: X,
+  useInternalState: l = !1
+}) => {
+  const Y = Fr(), [h, J] = m(d), [E, Z] = m(d), [b, K] = m(g), [v, O] = m({}), [A, _] = m(0), [I, rr] = m(!1), c = ar(pr), tr = U(null), a = U({}), i = l ? h : d, R = (r, t) => {
+    const e = r instanceof Array ? r : [r];
+    let o = [];
+    return e.forEach((s) => {
+      if (typeof s == "function") {
+        const n = s(t);
+        n && (o = [...o, n]);
+      }
+    }), o;
+  }, or = (r, t) => {
+    const e = r || i;
+    let o = f.pickBy(v, (s, n) => Object.keys(t).includes(n));
+    return f.forEach(t, (s, n) => {
+      const P = f.get(e, n), lr = R(s, P);
+      o = {
+        ...o,
+        [n]: lr
+      };
+    }), o;
+  }, y = (r, t = !0, e = null) => {
+    const o = or(r, e || a.current), s = Object.values(o).every((n) => n.length === 0);
+    return t && rr(s), s;
+  }, er = q((r) => {
+    const {
+      target: t
+    } = r;
+    !l && u ? u((e) => B(e, t)) : J((e) => B(e, t));
+  }, []), sr = (r, t, e) => {
+    if (e) {
+      let o = v;
+      const s = R(e, t);
+      s.length === 0 ? o = f.omit(o, r) : o = {
+        ...o,
+        [r]: s
+      }, O(o);
+    }
+  }, Q = q((r) => {
+    r && (r.preventDefault(), r.stopPropagation()), y(i) && T(i);
+  }, [i]), S = (r, t) => {
+    const e = t ? t instanceof Array ? t : [t] : [];
+    e.length > 0 ? (r((o) => {
+      const s = JSON.parse(JSON.stringify(o));
+      return e.forEach((n) => {
+        n && f.set(s, n, f.get(E, n));
+      }), s;
+    }), O((o) => (e.forEach((s) => {
+      delete o[s];
+    }), o))) : (r(JSON.parse(JSON.stringify(E))), O({}));
+  }, ir = (r) => {
+    S(!l && u ? u : J, r);
+  }, nr = (r) => {
+    const t = f.omit(a, r);
+    a.current = t;
+  }, N = (r) => {
+    r.preventDefault(), f.isEqual(i, E);
+  }, fr = () => {
+    let r = null;
+    return V || (r = {
+      onSubmit: (t) => t.preventDefault(),
+      onKeyPress: (t) => {
+        t && t.key === "Enter" && (t.preventDefault(), t.stopPropagation(), b && Q());
+      }
+    }), r;
+  }, D = () => {
+    if (!f.isEmpty(c)) {
+      const {
+        onChangedData: r
+      } = c;
+      C && !f.isEqual(i, C) ? r(!0) : r(!1);
+    }
+    u && l && u(i), p && p(y(i, !0)), V || (L(Q), k && k(ir), w && w(() => y(i))), f.isEmpty(i) && Z(i);
+  };
+  F(() => {
+    l && D();
+  }, [JSON.stringify(h), l]), F(() => {
+    !l && u && D();
+  }, [JSON.stringify(d), l]), F(() => (j && (c && c.setSecurityBeforeUnload(!0), window.addEventListener("beforeunload", N)), () => window.removeEventListener("beforeunload", N)), [j, N]), F(() => {
+    !V && g !== b && K(g);
+  }, [g]), F(() => {
+    const r = Object.values(a.current).reduce((t, e) => t + (e?.length || 0), 0);
+    a.current && p && A !== r && (_(r), p(y(i, !0, a.current)));
+  }, [a.current, A, p, JSON.stringify(i)]);
+  const cr = {
+    skeletonize: W,
+    handlerFieldChange: er,
+    handlerFieldValidate: sr,
+    handlerStoreValidators: (r, t) => {
+      a.current = {
+        ...a.current,
+        [r]: t
+      };
+    },
+    handlerRemoveValidators: nr,
+    data: l ? h : d,
+    originalData: E,
+    fieldErrors: v,
+    externalFieldErrors: H,
+    isFormValid: I
+  };
+  return /* @__PURE__ */ x.jsxs(ur, { children: [
+    /* @__PURE__ */ x.jsx(mr.Provider, { value: cr, children: /* @__PURE__ */ x.jsx("form", { id: Y, ref: tr, style: M, ...fr(), role: "presentation", className: `form-component ${z}`, children: X }) }),
+    /* @__PURE__ */ x.jsx(dr, { zIndex: "99999999", title: $ || "Dados Alterados", text: G || "Você possui dados alterados, confirma o fechamento?", visible: !f.isEmpty(c) && c.showQuestion, onConfirmClick: c ? c.onConfirmClick : () => {
+    }, onUnconfirmClick: c ? c.onUnconfirmClick : () => {
+    } })
+  ] });
+};
+export {
+  Ar as Field,
+  Dr as FieldArray,
+  Qr as FieldNumber,
+  Ur as FieldPeriod,
+  Cr as default
+};

package/lib/form/types.d.ts

@@ -0,0 +1,233 @@
+import { ChangeEvent, ComponentType, CSSProperties, MouseEventHandler, ReactNode } from 'react';
+import { AllOptions } from '../inputs/select/types';
+export type Validator = (value: string) => string | undefined;
+export type PeriodValidator = (value: {
+    inicial: string;
+    final: string;
+}) => string | undefined;
+export type OnFielChangeEvent = Event & {
+    target: HTMLInputElement;
+};
+export type CustomKeyboardEvent = ChangeEvent<HTMLInputElement> & {
+    keyCode: number;
+};
+type BaseFormProps = {
+    dataSource: object;
+    children: ReactNode;
+    onSubmit: (data: object) => void;
+    handlerSubmit: (value: () => void) => void;
+    handlerReset?: (value: () => void) => void;
+    handlerValidates?: (value: any) => void;
+    onValidateForm?: (value: boolean) => void;
+    submitOnPressEnterKey?: boolean;
+    style?: CSSProperties;
+    customClass?: string;
+    securityBeforeUnload?: boolean;
+    securityTitle?: string;
+    securityText?: string;
+    securityData?: object;
+    externalFieldErrors?: object;
+    skeletonize?: boolean;
+    disabled?: boolean;
+};
+type OnDataChange = React.Dispatch<React.SetStateAction<object>>;
+export type FormProps = BaseFormProps & ({
+    useInternalState?: false;
+    onDataChange: OnDataChange;
+} | {
+    useInternalState: true;
+    onDataChange?: OnDataChange;
+});
+type Data = {
+    [key: string]: any;
+};
+export interface IFieldProps extends WithFieldProps {
+    data?: Data;
+    originalData?: Data;
+    dataSource?: Data;
+    name: string;
+    value?: string;
+    label?: string;
+    handlerFieldChange?: (event: ChangeEvent<HTMLInputElement> | CustomKeyboardEvent) => ChangeEvent;
+    handlerFieldValidate?: (name: string, value: string, validatorsArray: Validator[] | Validator) => void;
+    component: ComponentType<any>;
+    componentType?: 'Radio' | 'Checkbox';
+    onChange?: (event: ChangeEvent) => ChangeEvent;
+    onBlur?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: ChangeEvent<HTMLInputElement>) => void;
+    validators?: Validator | Validator[];
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    externalFieldErrors?: {
+        [name: string]: string[];
+    };
+    externalMessagesErrors?: string[];
+    fieldId?: string;
+    scale?: number;
+    required?: boolean;
+    idKey?: string;
+    descriptionKey?: string;
+    showClearButton?: boolean;
+    gridLayout?: string;
+    allOptions?: AllOptions;
+    searchNotFoundText?: string;
+    min?: number;
+    max?: number;
+    autoFocus?: boolean;
+    autoCompleteMask?: 'left' | 'right';
+    mask?: string;
+    hint?: string | string[];
+    hintPosition?: 'below' | 'onLabelRight';
+    themePopover?: 'light' | 'dark';
+    popoverAlign?: 'right' | 'left';
+    displayCurrencySymbol?: boolean;
+    removeZeroLeft?: boolean;
+    textAlign?: 'left' | 'right';
+    disabled?: boolean;
+    currencySymbol?: string;
+    checked?: boolean;
+}
+export interface CustomEvent {
+    target: {
+        value: string[];
+        name: string;
+    };
+}
+export interface IFieldArrayProps extends WithFieldProps {
+    data?: Data;
+    originalData?: Data;
+    dataSource?: Data;
+    name: string;
+    handlerFieldChange?: (event: CustomEvent) => void;
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    validators?: Validator | Validator[];
+    valuePropName?: string;
+    changePropName?: string;
+    handlerSelecionados?: (ids: string[]) => void;
+    label?: string;
+    skipLabel?: boolean;
+    bordered?: boolean;
+    cols?: string;
+    labelContainerStyle?: object;
+    externalMessagesErrors?: string[];
+    idKey?: string;
+    descriptionKey?: string;
+    showClearButton?: boolean;
+    gridLayout?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    onBlur?: (event: ChangeEvent<HTMLInputElement>) => void;
+    handlerFieldValidate?: (name: string, value: string, validatorsArray: Validator[] | Validator) => void;
+    required?: boolean;
+    hint?: string | string[];
+    hintPosition?: 'below' | 'onLabelRight';
+    themePopover?: 'light' | 'dark';
+    popoverAlign?: 'right' | 'left';
+}
+export type PeriodChangeEvent = {
+    initial: string;
+    final: string;
+};
+type PeriodFieldChangeEvent = {
+    target: {
+        name: string;
+        value: {
+            [valueDate: string]: string;
+        };
+    };
+};
+export interface IFieldPeriodProps extends WithFieldProps {
+    data?: Data;
+    originalData?: Data;
+    nameDateInitial: string;
+    nameDateFinal: string;
+    handlerFieldChange?: (event: PeriodFieldChangeEvent) => PeriodFieldChangeEvent;
+    label?: string;
+    onBlur?: () => void;
+    validators?: PeriodValidator | PeriodValidator[];
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    externalMessagesErrors?: string[];
+    externalFieldErrors?: {
+        [name: string]: string[];
+    };
+    handlerFieldValidate?: (name: string, value: object, validatorsArray: PeriodValidator[] | PeriodValidator) => void;
+    onChange?: (event: PeriodChangeEvent) => PeriodChangeEvent;
+    gridLayout?: string;
+    hint?: string | string[];
+    hintPosition?: 'below' | 'onLabelRight';
+    themePopover?: 'light' | 'dark';
+    popoverAlign?: 'right' | 'left';
+}
+export interface FormContextProps {
+    skeletonize?: boolean;
+    handlerFieldChange: (event: OnFielChangeEvent) => void;
+    handlerFieldValidate: (name: string, value: string, validatorsArray: Validator[] | Validator) => void;
+    handlerStoreValidators: (fieldName: string, fieldValidates: Validator) => void;
+    handlerRemoveValidators: (fieldName: string) => void;
+    data: object;
+    originalData: object;
+    fieldErrors: object;
+    externalFieldErrors?: object;
+    isFormValid?: boolean;
+}
+export interface WithFieldProps {
+    name: string;
+    data?: Data;
+    handlerStoreValidators?: (name: string, validators: Validator | Validator[]) => void;
+    handlerRemoveValidators?: (name: string) => void;
+    validators?: Validator | Validator[] | PeriodValidator | PeriodValidator[];
+    customClass?: string;
+    component: ComponentType<any>;
+}
+export interface IWithFieldContext {
+    validatorFromComponent: Validator | Validator[] | undefined;
+    handlerSetValidatorFromComponent: (validator: Validator | Validator[]) => void;
+}
+export interface IWithFormSecurity {
+    onOpenChange?: (open: boolean) => void;
+    handlerClose?: () => void;
+    onClick?: MouseEventHandler;
+    children?: ReactNode;
+}
+export interface IFormSecurityContext {
+    onChangedData: (value: boolean) => void;
+    showQuestion: boolean;
+    onConfirmClick: () => void;
+    onUnconfirmClick: () => void;
+    setSecurityBeforeUnload: (value: boolean) => void;
+    securityBeforeUnload?: boolean;
+}
+export interface IEventParams {
+    name: string;
+    data?: object;
+    validators?: Validator | Validator[];
+    onBlur?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: CustomKeyboardEvent) => void;
+    handlerFieldValidate?: (name: string, value: string, validatorsArray: Validator[] | Validator) => void;
+    handlerFieldChange?: (event: ChangeEvent<HTMLInputElement> | CustomKeyboardEvent) => void;
+    validatorFromComponent?: Validator | Validator[];
+    component?: ComponentType<any>;
+}
+export interface IGetErrorMessagesParams {
+    name: string;
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    externalFieldErrors?: {
+        [name: string]: string[];
+    };
+    externalMessagesErrors?: string[];
+}
+export type FieldErrors = {
+    [name: string]: string[];
+};
+export type FieldValidator = {
+    [name: string]: Validator | Validator[];
+};
+export {};

package/lib/form/withFieldHOC.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { WithFieldProps } from './types';
+declare const withFieldHOC: <ComponentProps extends WithFieldProps>(WrappedComponent: React.ComponentType<ComponentProps>) => any;
+export default withFieldHOC;

package/lib/form/withFieldHOC.js

@@ -0,0 +1,62 @@
+import { j as v } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as y } from "../chunks/compiler-runtime.Cu50tn6L.js";
+import E, { useState as _, useEffect as j } from "react";
+import { FormContext as b, withFieldContext as A, getValidatorsArray as g } from "./helpers.js";
+const k = (F) => {
+  const w = (a) => {
+    const e = y.c(23), {
+      name: o,
+      validators: t,
+      handlerStoreValidators: n,
+      handlerRemoveValidators: i
+    } = a, [r, R] = _(void 0);
+    let s;
+    e[0] !== n || e[1] !== o || e[2] !== r || e[3] !== t ? (s = () => {
+      const p = g(t, r);
+      p && n && n(o, p);
+    }, e[0] = n, e[1] = o, e[2] = r, e[3] = t, e[4] = s) : s = e[4];
+    const l = s;
+    let f;
+    e[5] !== i || e[6] !== o || e[7] !== l || e[8] !== t ? (f = () => (l(), () => {
+      t && i && i(o);
+    }), e[5] = i, e[6] = o, e[7] = l, e[8] = t, e[9] = f) : f = e[9];
+    let d;
+    e[10] === Symbol.for("react.memo_cache_sentinel") ? (d = [], e[10] = d) : d = e[10], j(f, d);
+    let c;
+    e[11] !== l ? (c = () => {
+      l();
+    }, e[11] = l, e[12] = c) : c = e[12];
+    let u;
+    e[13] !== t ? (u = [t], e[13] = t, e[14] = u) : u = e[14], j(c, u);
+    let x;
+    e[15] === Symbol.for("react.memo_cache_sentinel") ? (x = (p) => {
+      R(p);
+    }, e[15] = x) : x = e[15];
+    let h;
+    e[16] !== r ? (h = {
+      validatorFromComponent: r,
+      handlerSetValidatorFromComponent: x
+    }, e[16] = r, e[17] = h) : h = e[17];
+    const V = h;
+    let m;
+    e[18] !== a ? (m = /* @__PURE__ */ v.jsx(F, { ...a }), e[18] = a, e[19] = m) : m = e[19];
+    let C;
+    return e[20] !== V || e[21] !== m ? (C = /* @__PURE__ */ v.jsx(A.Provider, { value: V, children: m }), e[20] = V, e[21] = m, e[22] = C) : C = e[22], C;
+  };
+  function S(a, e) {
+    return /* @__PURE__ */ v.jsx(b.Consumer, { children: ({
+      handlerFieldChange: o,
+      handlerFieldValidate: t,
+      data: n,
+      fieldErrors: i,
+      externalFieldErrors: r,
+      handlerStoreValidators: R,
+      handlerRemoveValidators: s,
+      skeletonize: l
+    }) => /* @__PURE__ */ v.jsx(w, { ...a, skeletonize: l, handlerFieldChange: o, handlerFieldValidate: t, handlerStoreValidators: R, handlerRemoveValidators: s, data: n, fieldErrors: i, externalFieldErrors: r, forwardedRef: e }) });
+  }
+  return E.forwardRef(S);
+};
+export {
+  k as default
+};

package/lib/form/withFormSecurity.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { IFormSecurityContext, IWithFormSecurity } from './types';
+declare const FormSecurityContext: React.Context<IFormSecurityContext>;
+declare const withFormSecurity: <ComponentProps extends IWithFormSecurity>(WrappedComponent: React.ComponentType<ComponentProps>) => (props: ComponentProps) => import("react/jsx-runtime").JSX.Element;
+export default withFormSecurity;
+export { FormSecurityContext };

package/lib/form/withFormSecurity.js

@@ -0,0 +1,30 @@
+import { j as a } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import d, { useRef as i, useState as m } from "react";
+const h = d.createContext({}), k = (l) => (r) => {
+  const {
+    onOpenChange: e,
+    handlerClose: n
+  } = r, s = i(!1), o = i(!1), [f, c] = m(!1), u = () => {
+    s.current && o.current ? c(!0) : e ? e(!1) : n && n();
+  }, C = {
+    onChangedData: (t) => {
+      s.current = t;
+    },
+    showQuestion: f,
+    onConfirmClick: () => {
+      e && e(!1), n && n();
+    },
+    onUnconfirmClick: () => {
+      c(!1);
+    },
+    setSecurityBeforeUnload: (t) => {
+      o.current = t;
+    },
+    securityBeforeUnload: o.current
+  };
+  return /* @__PURE__ */ a.jsx(h.Provider, { value: C, children: /* @__PURE__ */ a.jsx(l, { ...r, handlerClose: u }) });
+};
+export {
+  h as FormSecurityContext,
+  k as default
+};

package/lib/gridlayout/GridCol.d.ts

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

package/lib/gridlayout/GridCol.js

@@ -0,0 +1,27 @@
+import { j as d } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as p } from "../chunks/compiler-runtime.Cu50tn6L.js";
+import '../assets/gridlayout.css';/* empty css                            */
+const $ = (o) => {
+  const s = o ? o.split(" ") : [];
+  let t = "grid-container ";
+  return s[0] && (t += `col-xs-${s[0]}`), s[1] && (t += ` col-sm-${s[1]}`), s[2] && (t += ` col-md-${s[2]}`), s[3] && (t += ` col-lg-${s[3]}`), t;
+}, C = (o) => {
+  const s = p.c(6), {
+    cols: t,
+    customClass: a,
+    children: i,
+    style: c,
+    visible: m
+  } = o, f = m === void 0 ? !0 : m, r = t || "";
+  let l;
+  s[0] !== r ? (l = $(r), s[0] = r, s[1] = l) : l = s[1];
+  const u = l;
+  if (!f)
+    return null;
+  const n = `${a} ${u}`;
+  let e;
+  return s[2] !== i || s[3] !== c || s[4] !== n ? (e = /* @__PURE__ */ d.jsx("div", { className: n, style: c, children: i }), s[2] = i, s[3] = c, s[4] = n, s[5] = e) : e = s[5], e;
+};
+export {
+  C as default
+};

package/lib/gridlayout/GridRow.d.ts

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

package/lib/gridlayout/GridRow.js

@@ -0,0 +1,26 @@
+import { j as a } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as m } from "../chunks/compiler-runtime.Cu50tn6L.js";
+import '../assets/gridlayout.css';/* empty css                            */
+const v = (i) => `row ${i.customClass}
+    ${i.withTrim && " -withtrim"}
+    ${i.verticalAlign && ` align-items-${i.verticalAlign}`}
+    ${i.horizontalAlign && ` justify-content-${i.horizontalAlign}`}`, d = (i) => {
+  const t = m.c(7), {
+    style: n,
+    children: s,
+    verticalAlign: c,
+    visible: o
+  } = i, r = c === void 0 ? "start" : c;
+  if (!(o === void 0 ? !0 : o))
+    return null;
+  let l;
+  t[0] !== i || t[1] !== r ? (l = v({
+    ...i,
+    verticalAlign: r
+  }), t[0] = i, t[1] = r, t[2] = l) : l = t[2];
+  let e;
+  return t[3] !== s || t[4] !== n || t[5] !== l ? (e = /* @__PURE__ */ a.jsx("div", { style: n, className: l, children: s }), t[3] = s, t[4] = n, t[5] = l, t[6] = e) : e = t[6], e;
+};
+export {
+  d as default
+};

package/lib/gridlayout/gridLayout.spec.d.ts

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

package/lib/gridlayout/index.d.ts

@@ -0,0 +1,4 @@
+import { default as GridRow } from './GridRow';
+import { default as GridCol } from './GridCol';
+export default GridCol;
+export { GridRow };

package/lib/gridlayout/index.js

@@ -0,0 +1,6 @@
+import { default as d } from "./GridRow.js";
+import r from "./GridCol.js";
+export {
+  d as GridRow,
+  r as default
+};

package/lib/gridlayout/types.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface IGridCol {
+    children?: ReactNode | ReactNode[];
+    cols?: string;
+    customClass?: string;
+    style?: CSSProperties;
+    visible?: boolean;
+}
+export interface IGridRow {
+    children?: ReactNode | ReactNode[];
+    verticalAlign?: 'start' | 'center' | 'end' | 'baseline' | 'stretch';
+    horizontalAlign?: string;
+    style?: CSSProperties;
+    withTrim?: boolean;
+    visible?: boolean;
+    customClass?: string;
+}

package/lib/hint/helpers.d.ts

@@ -0,0 +1 @@
+export declare const showHintList: (arrayHint: string[]) => import("react/jsx-runtime").JSX.Element;

package/lib/hint/helpers.js

@@ -0,0 +1,12 @@
+import { j as s } from "../chunks/jsx-runtime.D1SHvdVE.js";
+const n = (t) => /* @__PURE__ */ s.jsx("div", { className: "rules-list", style: {
+  padding: "15px 0px"
+}, children: /* @__PURE__ */ s.jsx("ul", { style: {
+  listStyleType: "none"
+}, children: t.map((i, e) => /* @__PURE__ */ s.jsxs("li", { children: [
+  "-",
+  i
+] }, e.toString())) }) });
+export {
+  n as showHintList
+};

package/lib/hint/hint.spec.d.ts

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

package/lib/hint/index.d.ts

@@ -0,0 +1,3 @@
+import { HintProps } from './types';
+declare const Hint: ({ visible, description, customClass, skeletonize, style, disabled, color, }: HintProps) => import("react/jsx-runtime").JSX.Element | null;
+export default Hint;

package/lib/hint/index.js

@@ -0,0 +1,30 @@
+import { j as c } from "../chunks/jsx-runtime.D1SHvdVE.js";
+import { c as v } from "../chunks/compiler-runtime.Cu50tn6L.js";
+import { showHintList as x } from "./helpers.js";
+import '../assets/index8.css';const k = (m) => {
+  const s = v.c(8), {
+    visible: n,
+    description: t,
+    customClass: p,
+    skeletonize: a,
+    style: l,
+    disabled: d,
+    color: f
+  } = m, u = n === void 0 ? !0 : n, b = a === void 0 ? !1 : a, e = d === void 0 ? !1 : d;
+  if (!u || !t)
+    return null;
+  const r = `
+        hint-component
+        ${p}
+        ${b ? "-skeletonized" : ""}
+        ${e ? "-disabled" : ""}
+        -${f}
+      `;
+  let i;
+  s[0] !== t || s[1] !== e ? (i = Array.isArray(t) ? x(t) : /* @__PURE__ */ c.jsx("span", { "aria-disabled": e, children: t }), s[0] = t, s[1] = e, s[2] = i) : i = s[2];
+  let o;
+  return s[3] !== e || s[4] !== l || s[5] !== r || s[6] !== i ? (o = /* @__PURE__ */ c.jsx("div", { "aria-disabled": e, style: l, className: r, children: i }), s[3] = e, s[4] = l, s[5] = r, s[6] = i, s[7] = o) : o = s[7], o;
+};
+export {
+  k as default
+};

package/lib/hint/types.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties } from 'react';
+import { ColorStyles } from '../@types/ColorStyles';
+export interface HintProps {
+    description?: string | string[];
+    visible?: boolean;
+    customClass?: string;
+    skeletonize?: boolean;
+    disabled?: boolean;
+    style?: CSSProperties;
+    color?: ColorStyles;
+}