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

package/lib/form/index.js

@@ -0,0 +1,283 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Field", {
+  enumerable: true,
+  get: function () {
+    return _Field.default;
+  }
+});
+Object.defineProperty(exports, "FieldArray", {
+  enumerable: true,
+  get: function () {
+    return _FieldArray.default;
+  }
+});
+Object.defineProperty(exports, "FieldNumber", {
+  enumerable: true,
+  get: function () {
+    return _FieldNumber.default;
+  }
+});
+Object.defineProperty(exports, "FieldPeriod", {
+  enumerable: true,
+  get: function () {
+    return _FieldPeriod.default;
+  }
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _uuid = require("uuid");
+var _lodash = _interopRequireDefault(require("lodash"));
+var _helpers = require("./helpers");
+var _Field = _interopRequireDefault(require("./Field"));
+var _FieldNumber = _interopRequireDefault(require("./FieldNumber"));
+var _FieldArray = _interopRequireDefault(require("./FieldArray"));
+var _FieldPeriod = _interopRequireDefault(require("./FieldPeriod"));
+require("../assets/styles/form.scss");
+var _dialog = require("../dialog");
+var _withFormSecurity = require("./withFormSecurity");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+function 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); }
+const Form = _ref => {
+  let {
+    submitOnPressEnterKey = true,
+    dataSource,
+    securityBeforeUnload,
+    handlerReset,
+    handlerSubmit,
+    handlerValidates,
+    style,
+    customClass,
+    securityTitle,
+    securityText,
+    securityData,
+    onDataChange,
+    onValidateForm,
+    externalFieldErrors,
+    onSubmit,
+    skeletonize,
+    disabled,
+    children,
+    useInternalState = false
+  } = _ref;
+  const formId = (0, _uuid.v1)();
+  const [data, setData] = (0, _react.useState)(dataSource);
+  const [originalData, setOriginalData] = (0, _react.useState)(dataSource);
+  const [submitFormOnEnter, setSubmitFormOnEnter] = (0, _react.useState)(submitOnPressEnterKey);
+  const [fieldErrors, setFieldErrors] = (0, _react.useState)({});
+  const [oldFieldsValidatorsQuantity, setOldFieldsValidatorsQuantity] = (0, _react.useState)(0);
+  const [isValid, setIsValid] = (0, _react.useState)(false);
+  const context = (0, _react.useContext)(_withFormSecurity.FormSecurityContext);
+  const formRef = (0, _react.useRef)(null);
+  const fieldsValidators = (0, _react.useRef)({});
+  const usedData = useInternalState ? data : dataSource;
+  const getValidatesErrorMessages = (validators, fieldValue) => {
+    const validatorsArray = !(validators instanceof Array) ? [validators] : validators;
+    let errors = [];
+    validatorsArray.forEach(validator => {
+      if (typeof validator === 'function') {
+        const result = validator(fieldValue);
+        if (result) errors = [...errors, result];
+      }
+    });
+    return errors;
+  };
+  const getErrorMessages = (currentData, currentValidators) => {
+    const dataValidate = currentData || usedData;
+    let currentFieldErrors = _lodash.default.pickBy(fieldErrors, (error, fieldName) => {
+      const fieldValidatorsNames = Object.keys(currentValidators);
+      return fieldValidatorsNames.includes(fieldName);
+    });
+    _lodash.default.forEach(currentValidators, (validators, fieldName) => {
+      const fieldValue = _lodash.default.get(dataValidate, fieldName);
+      const messages = getValidatesErrorMessages(validators, fieldValue);
+      currentFieldErrors = _objectSpread(_objectSpread({}, currentFieldErrors), {}, {
+        [fieldName]: messages
+      });
+    });
+    return currentFieldErrors;
+  };
+  const checkIsValid = function (currentData) {
+    let updateState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let currentValidators = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    const currentFieldErrors = getErrorMessages(currentData, currentValidators || fieldsValidators.current);
+    const isValidNow = Object.values(currentFieldErrors).every(value => value.length === 0);
+    if (updateState) setIsValid(isValidNow);
+    return isValidNow;
+  };
+  const onFieldChange = (0, _react.useCallback)(event => {
+    const {
+      target
+    } = event;
+    if (!useInternalState && onDataChange) {
+      onDataChange(prevState => (0, _helpers.changeValue)(prevState, target));
+    } else {
+      setData(prevState => (0, _helpers.changeValue)(prevState, target));
+    }
+  }, []);
+  const onValidate = (fieldName, fieldValue, validators) => {
+    if (validators) {
+      let currentFieldErrors = fieldErrors;
+      const errors = getValidatesErrorMessages(validators, fieldValue);
+      if (errors.length === 0) {
+        currentFieldErrors = _lodash.default.omit(currentFieldErrors, fieldName);
+      } else {
+        currentFieldErrors = _objectSpread(_objectSpread({}, currentFieldErrors), {}, {
+          [fieldName]: errors
+        });
+      }
+      setFieldErrors(currentFieldErrors);
+    }
+  };
+  const onFormSubmit = (0, _react.useCallback)(event => {
+    if (event) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    if (checkIsValid(usedData)) onSubmit(usedData);
+  }, [usedData]);
+  const onResetField = (cb, fields) => {
+    const fieldsArray = !fields ? [] : fields instanceof Array ? fields : [fields];
+    if (fieldsArray.length > 0) {
+      cb(state => {
+        const newState = JSON.parse(JSON.stringify(state));
+        fieldsArray.forEach(field => {
+          if (field) _lodash.default.set(newState, field, _lodash.default.get(originalData, field));
+        });
+        return newState;
+      });
+      setFieldErrors(state => {
+        fieldsArray.forEach(field => {
+          delete state[field];
+        });
+        return state;
+      });
+    } else {
+      cb(JSON.parse(JSON.stringify(originalData)));
+      setFieldErrors({});
+    }
+  };
+  const onReset = fields => {
+    if (!useInternalState && onDataChange) {
+      onResetField(onDataChange, fields);
+    } else {
+      onResetField(setData, fields);
+    }
+  };
+  const onRemoveFieldValidators = fieldName => {
+    const newFieldsValidators = _lodash.default.omit(fieldsValidators, fieldName);
+    fieldsValidators.current = newFieldsValidators;
+  };
+  const onBeforeUnload = e => {
+    const event = e;
+    event.preventDefault();
+    if (_lodash.default.isEqual(usedData, originalData)) return;
+  };
+  const formProps = () => {
+    let propsForm = null;
+    if (!disabled) {
+      propsForm = {
+        onSubmit: event => event.preventDefault(),
+        onKeyPress: event => {
+          if (event && event.key === 'Enter') {
+            event.preventDefault();
+            event.stopPropagation();
+            if (submitFormOnEnter) onFormSubmit();
+          }
+        }
+      };
+    }
+    return propsForm;
+  };
+  const updateFormState = () => {
+    if (!_lodash.default.isEmpty(context)) {
+      const {
+        onChangedData
+      } = context;
+      if (securityData && !_lodash.default.isEqual(usedData, securityData)) {
+        onChangedData(true);
+      } else {
+        onChangedData(false);
+      }
+    }
+    if (onDataChange && useInternalState) onDataChange(usedData);
+
+    // TODO - Usar debounce para evitar chamada a cada letra digitada
+    if (onValidateForm) onValidateForm(checkIsValid(usedData, true));
+    if (!disabled) {
+      handlerSubmit(onFormSubmit);
+      if (handlerReset) handlerReset(onReset);
+      if (handlerValidates) handlerValidates(() => checkIsValid(usedData));
+    }
+    if (_lodash.default.isEmpty(usedData)) setOriginalData(usedData);
+  };
+  (0, _react.useEffect)(() => {
+    if (useInternalState) updateFormState();
+  }, [JSON.stringify(data), useInternalState]);
+  (0, _react.useEffect)(() => {
+    if (!useInternalState && onDataChange) updateFormState();
+  }, [JSON.stringify(dataSource), useInternalState]);
+  (0, _react.useEffect)(() => {
+    if (securityBeforeUnload) {
+      if (context) context.setSecurityBeforeUnload(true);
+      window.addEventListener('beforeunload', onBeforeUnload);
+    }
+    return () => window.removeEventListener('beforeunload', onBeforeUnload);
+  }, [securityBeforeUnload, onBeforeUnload]);
+  (0, _react.useEffect)(() => {
+    if (!disabled && submitOnPressEnterKey !== submitFormOnEnter) {
+      setSubmitFormOnEnter(submitOnPressEnterKey);
+    }
+  }, [submitOnPressEnterKey]);
+  (0, _react.useEffect)(() => {
+    const validatorsQuantity = Object.values(fieldsValidators.current).reduce((acc, currentValue) => acc + (currentValue?.length || 0), 0);
+    if (fieldsValidators.current && onValidateForm && oldFieldsValidatorsQuantity !== validatorsQuantity) {
+      setOldFieldsValidatorsQuantity(validatorsQuantity);
+      onValidateForm(checkIsValid(usedData, true, fieldsValidators.current));
+    }
+  }, [fieldsValidators.current, oldFieldsValidatorsQuantity, onValidateForm, JSON.stringify(usedData)]);
+  const contextValues = {
+    skeletonize,
+    handlerFieldChange: onFieldChange,
+    handlerFieldValidate: onValidate,
+    handlerStoreValidators: (fieldName, fieldValidates) => {
+      fieldsValidators.current = _objectSpread(_objectSpread({}, fieldsValidators.current), {}, {
+        [fieldName]: fieldValidates
+      });
+    },
+    handlerRemoveValidators: onRemoveFieldValidators,
+    data: useInternalState ? data : dataSource,
+    originalData,
+    fieldErrors,
+    externalFieldErrors,
+    isFormValid: isValid
+  };
+  return /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement(_helpers.FormContext.Provider, {
+    value: contextValues
+  }, /*#__PURE__*/_react.default.createElement("form", _extends({
+    id: formId,
+    ref: formRef,
+    style: style
+  }, formProps(), {
+    role: "presentation",
+    className: `form-component ${customClass}`
+  }), children)), /*#__PURE__*/_react.default.createElement(_dialog.DialogQuestion, {
+    zIndex: "99999999",
+    title: securityTitle || 'Dados Alterados',
+    text: securityText || 'Você possui dados alterados, confirma o fechamento?',
+    visible: !_lodash.default.isEmpty(context) && context.showQuestion,
+    onConfirmClick: context ? context.onConfirmClick : () => {},
+    onUnconfirmClick: context ? context.onUnconfirmClick : () => {}
+  }));
+};
+var _default = exports.default = Form;

package/lib/form/types.d.ts

@@ -0,0 +1,243 @@
+import { ChangeEvent, ComponentType, MouseEventHandler, ReactNode, CSSProperties } from 'react';
+import { AllOptions } from '../inputs/select/types.js';
+import '../@types/Align.js';
+import '../@types/DataCombo.js';
+import '../@types/PermissionAttr.js';
+import '../inputs/base/types.js';
+import '../@types/Period.js';
+import '../internals/types.js';
+import '../@types/Position.js';
+
+type Validator = (value: string) => string | undefined;
+type PeriodValidator = (value: {
+    inicial: string;
+    final: string;
+}) => string | undefined;
+type OnFielChangeEvent = Event & {
+    target: HTMLInputElement;
+};
+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>>;
+type FormProps = BaseFormProps & ({
+    useInternalState?: false;
+    onDataChange: OnDataChange;
+} | {
+    useInternalState: true;
+    onDataChange?: OnDataChange;
+});
+type Data = {
+    [key: string]: any;
+};
+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;
+}
+interface CustomEvent {
+    target: {
+        value: string[];
+        name: string;
+    };
+}
+interface IFieldArrayProps extends WithFieldProps {
+    data?: Data;
+    originalData?: Data;
+    dataSource?: Data;
+    name: string;
+    handlerFieldChange?: (event: CustomEvent) => void;
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    component?: ComponentType<any>;
+    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';
+}
+type PeriodChangeEvent = {
+    initial: string;
+    final: string;
+};
+type PeriodFieldChangeEvent = {
+    target: {
+        name: string;
+        value: {
+            [valueDate: string]: string;
+        };
+    };
+};
+interface IFieldPeriodProps extends WithFieldProps {
+    data?: Data;
+    originalData?: Data;
+    nameDateInitial: string;
+    nameDateFinal: string;
+    handlerFieldChange?: (event: PeriodFieldChangeEvent) => PeriodFieldChangeEvent;
+    label?: string;
+    component?: ComponentType<any>;
+    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';
+}
+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;
+}
+interface WithFieldProps {
+    name: string;
+    data?: Data;
+    handlerStoreValidators?: (name: string, validators: Validator | Validator[]) => void;
+    handlerRemoveValidators?: (name: string) => void;
+    validators?: Validator | Validator[] | PeriodValidator | PeriodValidator[];
+    customClass?: string;
+}
+interface IWithFieldContext {
+    validatorFromComponent: Validator | Validator[] | undefined;
+    handlerSetValidatorFromComponent: (validator: Validator | Validator[]) => void;
+}
+interface IWithFormSecurity {
+    onOpenChange?: (open: boolean) => void;
+    handlerClose?: () => void;
+    onClick?: MouseEventHandler;
+    children?: ReactNode;
+}
+interface IFormSecurityContext {
+    onChangedData: (value: boolean) => void;
+    showQuestion: boolean;
+    onConfirmClick: () => void;
+    onUnconfirmClick: () => void;
+    setSecurityBeforeUnload: (value: boolean) => void;
+    securityBeforeUnload?: boolean;
+}
+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>;
+}
+interface IGetErrorMessagesParams {
+    name: string;
+    fieldErrors?: {
+        [name: string]: string[];
+    };
+    externalFieldErrors?: {
+        [name: string]: string[];
+    };
+    externalMessagesErrors?: string[];
+}
+type FieldErrors = {
+    [name: string]: string[];
+};
+type FieldValidator = {
+    [name: string]: Validator | Validator[];
+};
+
+export { CustomEvent, CustomKeyboardEvent, FieldErrors, FieldValidator, FormContextProps, FormProps, IEventParams, IFieldArrayProps, IFieldPeriodProps, IFieldProps, IFormSecurityContext, IGetErrorMessagesParams, IWithFieldContext, IWithFormSecurity, OnFielChangeEvent, PeriodChangeEvent, PeriodValidator, Validator, WithFieldProps };

package/lib/form/types.js

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

package/lib/form/withFieldHOC.d.ts

@@ -0,0 +1,14 @@
+import React__default from 'react';
+import { WithFieldProps } from './types.js';
+import '../inputs/select/types.js';
+import '../@types/Align.js';
+import '../@types/DataCombo.js';
+import '../@types/PermissionAttr.js';
+import '../inputs/base/types.js';
+import '../@types/Period.js';
+import '../internals/types.js';
+import '../@types/Position.js';
+
+declare const withFieldHOC: <ComponentProps extends WithFieldProps>(WrappedComponent: React__default.ComponentType<ComponentProps>) => React__default.ForwardRefExoticComponent<React__default.PropsWithoutRef<ComponentProps> & React__default.RefAttributes<HTMLElement>>;
+
+export { withFieldHOC as default };

package/lib/form/withFieldHOC.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _helpers = require("./helpers");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+const withFieldHOC = WrappedComponent => {
+  const EnhancedComponent = props => {
+    const {
+      name,
+      validators,
+      handlerStoreValidators,
+      handlerRemoveValidators
+    } = props;
+    const [validatorFromComponent, setValidatorFromComponent] = (0, _react.useState)(undefined);
+    const updateValidators = () => {
+      const validatorsArray = (0, _helpers.getValidatorsArray)(validators, validatorFromComponent);
+      if (validatorsArray && handlerStoreValidators) handlerStoreValidators(name, validatorsArray);
+    };
+    (0, _react.useEffect)(() => {
+      updateValidators();
+      return () => {
+        if (validators && handlerRemoveValidators) handlerRemoveValidators(name);
+      };
+    }, []);
+    (0, _react.useEffect)(() => {
+      updateValidators();
+    }, [validators]);
+    const contextValues = {
+      validatorFromComponent,
+      handlerSetValidatorFromComponent: validator => {
+        setValidatorFromComponent(validator);
+      }
+    };
+    return /*#__PURE__*/_react.default.createElement(_helpers.withFieldContext.Provider, {
+      value: contextValues
+    }, /*#__PURE__*/_react.default.createElement(WrappedComponent, props));
+  };
+  function forwardRef(props, ref) {
+    return /*#__PURE__*/_react.default.createElement(_helpers.FormContext.Consumer, null, _ref => {
+      let {
+        handlerFieldChange,
+        handlerFieldValidate: handlerFieldValidate,
+        data,
+        fieldErrors,
+        externalFieldErrors,
+        handlerStoreValidators,
+        handlerRemoveValidators,
+        skeletonize
+      } = _ref;
+      return /*#__PURE__*/_react.default.createElement(EnhancedComponent, _extends({}, props, {
+        skeletonize: skeletonize,
+        handlerFieldChange: handlerFieldChange,
+        handlerFieldValidate: handlerFieldValidate,
+        handlerStoreValidators: handlerStoreValidators,
+        handlerRemoveValidators: handlerRemoveValidators,
+        data: data,
+        fieldErrors: fieldErrors,
+        externalFieldErrors: externalFieldErrors,
+        forwardedRef: ref
+      }));
+    });
+  }
+  return /*#__PURE__*/_react.default.forwardRef(forwardRef);
+};
+var _default = exports.default = withFieldHOC;

package/lib/form/withFormSecurity.d.ts

@@ -0,0 +1,15 @@
+import React__default from 'react';
+import { IFormSecurityContext, IWithFormSecurity } from './types.js';
+import '../inputs/select/types.js';
+import '../@types/Align.js';
+import '../@types/DataCombo.js';
+import '../@types/PermissionAttr.js';
+import '../inputs/base/types.js';
+import '../@types/Period.js';
+import '../internals/types.js';
+import '../@types/Position.js';
+
+declare const FormSecurityContext: React__default.Context<IFormSecurityContext>;
+declare const withFormSecurity: <ComponentProps extends IWithFormSecurity>(WrappedComponent: React__default.ComponentType<ComponentProps>) => (props: ComponentProps) => JSX.Element;
+
+export { FormSecurityContext, withFormSecurity as default };