rb-document-form-constructor 0.8.75 → 0.8.76

package/dist/rb-document-form-constructor.esm.js

@@ -1,11 +1,11 @@
 import Vue$1 from 'vue';
-import crypto from 'crypto';
 
 const UtFormConfig = {
   findField(fieldName, formConfig) {
     if (!formConfig || !formConfig.sections) {
       return null;
     }
+
     let found = null;
     formConfig.sections.every(r => {
       if (r.columns) {
@@ -15,21 +15,25 @@ const UtFormConfig = {
               found = f;
             }
           });
+
           if (found) {
             return false;
           }
         });
       }
+
       if (found) {
         return false;
       }
     });
     return found;
   },
+
   findRule(ruleId, formConfig) {
     if (!formConfig || !formConfig.sections) {
       return null;
     }
+
     let found = null;
     formConfig.sections.every(s => {
       if (s.columns) {
@@ -42,21 +46,25 @@ const UtFormConfig = {
                 }
               });
             }
+
             if (found) {
               return false;
             }
           });
+
           if (found) {
             return false;
           }
         });
       }
+
       if (found) {
         return false;
       }
     });
     return found;
   },
+
   getFields(formConfig) {
     let fields = [];
     formConfig.sections.forEach(s => {
@@ -72,6 +80,7 @@ const UtFormConfig = {
     });
     return fields;
   },
+
   parseFacets(formConfig) {
     let facets = [];
     formConfig.sections.forEach(section => {
@@ -85,6 +94,7 @@ const UtFormConfig = {
     });
     return facets;
   }
+
 };
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -4786,19 +4796,25 @@ notevil.Function = _Function;
 let __clone = function (data) {
   return JSON.parse(JSON.stringify(data));
 };
+
 let __assign = function () {
   __assign = Object.assign || function __assign(t) {
     for (let s, i = 1, n = arguments.length; i < n; i++) {
       s = arguments[i];
+
       for (let p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
     }
+
     return t;
   };
+
   return __assign.apply(this, arguments);
 };
+
 let __mergeInputInMapOfArrays = function (inputs, formConfigInputs) {
   for (let dataType in formConfigInputs) {
     let foundInputs = inputs[dataType];
+
     if (foundInputs) {
       __mergeInputsInArray(foundInputs, formConfigInputs[dataType]);
     } else {
@@ -4806,14 +4822,17 @@ let __mergeInputInMapOfArrays = function (inputs, formConfigInputs) {
     }
   }
 };
+
 let __mergeInputsInMap = function (inputs, formConfigInputs) {
   for (let name in formConfigInputs) {
     inputs[name] = __assign(inputs[name] ? inputs[name] : {}, formConfigInputs[name] ? formConfigInputs[name] : {});
   }
 };
+
 let __mergeInputsInArray = function (inputs, formConfigInputs) {
   formConfigInputs.forEach(input => {
     let index = inputs.findIndex(item => item.name === input.name);
+
     if (index >= 0) {
       inputs[index] = input;
     } else {
@@ -4821,12 +4840,16 @@ let __mergeInputsInArray = function (inputs, formConfigInputs) {
     }
   });
 };
+
 let __applyDefaultProps = function (input, field) {
   for (let propName in input.props) {
     if (field) {
       if (field.input.propsData[propName]) {
+        var _input$propsData, _input$props, _input$props$type;
+
         input.propsData[propName] = field.input.propsData[propName];
-        if (input.propsData?.type && input.props?.type?.default) {
+
+        if ((_input$propsData = input.propsData) !== null && _input$propsData !== void 0 && _input$propsData.type && (_input$props = input.props) !== null && _input$props !== void 0 && (_input$props$type = _input$props.type) !== null && _input$props$type !== void 0 && _input$props$type.default) {
           input.propsData.type = input.props.type.default;
         }
       }
@@ -4835,18 +4858,21 @@ let __applyDefaultProps = function (input, field) {
     }
   }
 };
+
 let __applyRefProps = function (input, refConfig) {
-  if (refConfig?.propsData) {
+  if (refConfig !== null && refConfig !== void 0 && refConfig.propsData) {
     for (let propName in refConfig.propsData) {
       input.propsData[propName] = refConfig.propsData[propName];
     }
   }
 };
+
 let __filterInputsByMultiple = function (inputs, multiple) {
   return inputs.filter(i => {
     return i.multiple && multiple || !i.multiple && !multiple;
   });
 };
+
 let fcInputs = {
   string: {
     text: 'Текст',
@@ -5048,40 +5074,52 @@ let baseConfig = {
 };
 const UtFormConstructor = {
   config: {},
+
   init(formConfig) {
     this.config = __clone(baseConfig);
+
     if (formConfig) {
       if (formConfig.inputs) {
         __mergeInputsInMap(this.config.inputs, formConfig.inputs);
       }
+
       if (formConfig.primitiveInputs) {
         __mergeInputInMapOfArrays(this.config.primitiveInputs, formConfig.primitiveInputs);
       }
+
       if (formConfig.dictInputs) {
         __mergeInputsInArray(this.config.dictInputs, formConfig.dictInputs);
       }
+
       if (formConfig.refInputs) {
         __mergeInputInMapOfArrays(this.config.refInputs, formConfig.refInputs);
       }
+
       if (formConfig.refInputConfigs) {
         this.config.refInputConfigs = formConfig.refInputConfigs;
       }
+
       if (formConfig.icons) {
         this.config.icons = __assign(this.config.icons, formConfig.icons);
       }
+
       if (formConfig.rules) {
         this.config.rules = formConfig.rules;
       }
+
       if (formConfig.ruleContext) {
         this.config.ruleContext = formConfig.ruleContext;
       }
     }
   },
+
   getInputTypes(field) {
     let inputs = [];
+
     if (!field) {
       return inputs;
     }
+
     if (field.dict && !this.config.refInputs[field.ref]) {
       inputs = __filterInputsByMultiple(this.config.dictInputs, field.multiple);
     } else if (field.ref) {
@@ -5089,71 +5127,91 @@ const UtFormConstructor = {
     } else {
       inputs = __filterInputsByMultiple(this.config.primitiveInputs[field.type], field.multiple);
     }
+
     return inputs;
   },
+
   hasMultipleInputTypes(field) {
-    let inputs = this.getInputTypes({
-      ...field,
+    let inputs = this.getInputTypes({ ...field,
       multiple: true
     });
     return inputs && inputs.length > 0;
   },
+
   getDefaultInput(field) {
     let input = null;
     let inputs = this.getInputTypes(field);
+
     if (!inputs) {
       input = this.primitiveInputs[0];
     }
+
     if (field.ref && this.config.refInputs[field.ref]) {
       input = __clone(inputs[0]);
+
       __applyDefaultProps(input);
+
       if (this.config.refInputConfigs[field.ref] && this.config.refInputConfigs[field.ref][input.name]) {
         __applyRefProps(input, this.config.refInputConfigs[field.ref][input.name]);
       }
     } else if (field.dict) {
       input = __clone(inputs[0]);
       input.props.dict.default = field.ref;
+
       __applyDefaultProps(input);
     } else {
       input = __clone(inputs[0]);
+
       __applyDefaultProps(input);
     }
+
     return input;
   },
+
   getInputTypeByName(name, field) {
     let input = __clone(this.config.inputs[name]);
+
     if (field.ref && this.config.refInputs[field.ref]) {
       __applyDefaultProps(input);
+
       if (this.config.refInputConfigs[field.ref] && this.config.refInputConfigs[field.ref][input.name]) {
         __applyRefProps(input, this.config.refInputConfigs[field.ref][input.name]);
       }
     } else if (field.dict) {
       input.props.dict.default = field.ref;
+
       __applyDefaultProps(input);
     } else {
       __applyDefaultProps(input, field);
     }
+
     input.propsData['ref'] = field.name;
     return input;
   },
+
   getAvailableFieldRules(field) {
     return this.config.rules.filter(rule => {
       return !rule.fields || rule.fields.length === 0 || rule.fields.indexOf(field.name) >= 0;
     });
   },
+
   getRuleContext() {
     return this.config.ruleContext;
   },
+
   runRule(context, script) {
     context = context ? context : {};
     context['console'] = console;
     context['Date'] = Date;
     context['Math'] = Math;
+
     let func = function (script) {
       return notevil(script, context);
     };
+
     func.call(context, script);
   }
+
 };
 
 /*!
@@ -7416,7 +7474,6 @@ const i18n = new VueI18n$1({
 //
 //
 //
-
 var script$5 = {
   name: 'DocTemplateSectionModal',
   props: {
@@ -7430,16 +7487,19 @@ var script$5 = {
       default: () => {}
     }
   },
+
   data() {
     return {
       id: 'rb-doc-template-section-modal',
       label: {}
     };
   },
+
   computed: {
     title() {
       return this.mode === 'ins' ? 'Добавление секции' : 'Редактирование секции';
     }
+
   },
   watch: {
     section() {
@@ -7447,23 +7507,29 @@ var script$5 = {
         this.label = this.section;
       }
     }
+
   },
   methods: {
     onOk() {
       this.section = this.label;
+
       if (this.onAfterOk) {
         this.onAfterOk();
       }
+
       this.$nextTick(() => {
         this.$bvModal.hide(this.id);
       });
     }
+
   },
+
   created() {
     if (this.section) {
       this.label = this.section;
     }
   }
+
 };
 
 function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
@@ -7543,12 +7609,15 @@ function normalizeComponent(template, style, script, scopeId, isFunctionalTempla
 
 /* script */
 const __vue_script__$5 = script$5;
-
 /* template */
+
 var __vue_render__$5 = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _c('b-modal', {
     attrs: {
       "id": "rb-doc-template-section-modal",
@@ -7589,15 +7658,19 @@ var __vue_render__$5 = function () {
     }
   })], 1)], 1)], 1)], 1)], 1);
 };
-var __vue_staticRenderFns__$5 = [];
 
+var __vue_staticRenderFns__$5 = [];
 /* style */
+
 const __vue_inject_styles__$5 = undefined;
 /* scoped */
+
 const __vue_scope_id__$5 = undefined;
 /* module identifier */
+
 const __vue_module_identifier__$5 = undefined;
 /* functional template */
+
 const __vue_is_functional_template__$5 = false;
 /* style inject */
 
@@ -7609,6 +7682,7 @@ const __vue_component__$6 = /*#__PURE__*/normalizeComponent({
   render: __vue_render__$5,
   staticRenderFns: __vue_staticRenderFns__$5
 }, __vue_inject_styles__$5, __vue_script__$5, __vue_scope_id__$5, __vue_is_functional_template__$5, __vue_module_identifier__$5, false, undefined, undefined, undefined);
+
 var DocTemplateSectionModal = __vue_component__$6;
 
 /**!
@@ -12995,6 +13069,7 @@ var script$4 = {
       default: () => []
     }
   },
+
   data() {
     return {
       allFacets: [],
@@ -13002,21 +13077,26 @@ var script$4 = {
       facetSearchStr: null
     };
   },
+
   computed: {
     iconExpandFacet() {
       return UtFormConstructor.config.icons.iconExpandFacet;
     },
+
     iconCollapseFacet() {
       return UtFormConstructor.config.icons.iconCollapseFacet;
     }
+
   },
   watch: {
     facetSearchStr() {
       this.findInFacets(this.facetSearchStr);
     },
+
     facets() {
       this.handleFacetsProp();
     }
+
   },
   methods: {
     onFieldCloned(cloneField) {
@@ -13024,55 +13104,69 @@ var script$4 = {
       field.input = UtFormConstructor.getDefaultInput(field);
       return field;
     },
+
     onFieldMoveEnd(event) {
       this.$emit('fieldMoveEnd', event);
     },
+
     findInFacets(str) {
       str = str.toLowerCase();
+
       if (!str || str.length === 0) {
         this.innerFacets = this.allFacets;
       }
+
       let facets = JSON.parse(JSON.stringify(this.allFacets));
       facets = facets.filter(facet => {
         let facetFound = false;
         facet.fields = facet.fields.filter(field => {
           let fieldFound = field.labelRu.toLowerCase().indexOf(str) >= 0;
+
           if (fieldFound) {
             facetFound = true;
           }
+
           return fieldFound;
         });
         return facetFound;
       });
       this.innerFacets = facets;
     },
+
     handleFacetsProp() {
-      let innerFacets = this.facets.map(f => ({
-        ...f,
+      let innerFacets = this.facets.map(f => ({ ...f,
         expanded: false
       }));
+
       if (innerFacets) {
         innerFacets.forEach(facet => {
           facet.fields = facet.fields.filter(field => !field.hiddenOnFormConfig);
         });
       }
+
       this.innerFacets = JSON.parse(JSON.stringify(innerFacets));
       this.allFacets = JSON.parse(JSON.stringify(innerFacets));
     }
+
   },
+
   created() {
     this.handleFacetsProp();
   }
+
 };
 
 /* script */
 const __vue_script__$4 = script$4;
-
 /* template */
+
 var __vue_render__$4 = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _c('div', {
     staticClass: "rb-facets-sidebar"
   }, [_c('h4', [_vm._v("Компоненты")]), _vm._v(" "), _c('b-form', [_c('b-form-row', [_c('b-col', {
@@ -13143,15 +13237,19 @@ var __vue_render__$4 = function () {
     }), 1)], 1) : _vm._e()], 1) : _vm._e();
   }), 0)], 1);
 };
-var __vue_staticRenderFns__$4 = [];
 
+var __vue_staticRenderFns__$4 = [];
 /* style */
+
 const __vue_inject_styles__$4 = undefined;
 /* scoped */
+
 const __vue_scope_id__$4 = undefined;
 /* module identifier */
+
 const __vue_module_identifier__$4 = undefined;
 /* functional template */
+
 const __vue_is_functional_template__$4 = false;
 /* style inject */
 
@@ -13163,183 +13261,8 @@ const __vue_component__$5 = /*#__PURE__*/normalizeComponent({
   render: __vue_render__$4,
   staticRenderFns: __vue_staticRenderFns__$4
 }, __vue_inject_styles__$4, __vue_script__$4, __vue_scope_id__$4, __vue_is_functional_template__$4, __vue_module_identifier__$4, false, undefined, undefined, undefined);
-var DocTemplateFacetList = __vue_component__$5;
-
-// Unique ID creation requires a high quality random # generator.  In node.js
-// this is pretty straight-forward - we use the crypto API.
-
-
-
-var rng = function nodeRNG() {
-  return crypto.randomBytes(16);
-};
-
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
-  byteToHex[i] = (i + 0x100).toString(16).substr(1);
-}
-
-function bytesToUuid(buf, offset) {
-  var i = offset || 0;
-  var bth = byteToHex;
-  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
-  return ([
-    bth[buf[i++]], bth[buf[i++]],
-    bth[buf[i++]], bth[buf[i++]], '-',
-    bth[buf[i++]], bth[buf[i++]], '-',
-    bth[buf[i++]], bth[buf[i++]], '-',
-    bth[buf[i++]], bth[buf[i++]], '-',
-    bth[buf[i++]], bth[buf[i++]],
-    bth[buf[i++]], bth[buf[i++]],
-    bth[buf[i++]], bth[buf[i++]]
-  ]).join('');
-}
-
-var bytesToUuid_1 = bytesToUuid;
-
-// **`v1()` - Generate time-based UUID**
-//
-// Inspired by https://github.com/LiosK/UUID.js
-// and http://docs.python.org/library/uuid.html
-
-var _nodeId;
-var _clockseq;
-
-// Previous uuid creation time
-var _lastMSecs = 0;
-var _lastNSecs = 0;
-
-// See https://github.com/uuidjs/uuid for API details
-function v1(options, buf, offset) {
-  var i = buf && offset || 0;
-  var b = buf || [];
-
-  options = options || {};
-  var node = options.node || _nodeId;
-  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
-
-  // node and clockseq need to be initialized to random values if they're not
-  // specified.  We do this lazily to minimize issues related to insufficient
-  // system entropy.  See #189
-  if (node == null || clockseq == null) {
-    var seedBytes = rng();
-    if (node == null) {
-      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
-      node = _nodeId = [
-        seedBytes[0] | 0x01,
-        seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]
-      ];
-    }
-    if (clockseq == null) {
-      // Per 4.2.2, randomize (14 bit) clockseq
-      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
-    }
-  }
-
-  // UUID timestamps are 100 nano-second units since the Gregorian epoch,
-  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
-  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
-  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
-  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
-
-  // Per 4.2.1.2, use count of uuid's generated during the current clock
-  // cycle to simulate higher resolution clock
-  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
-
-  // Time since last uuid creation (in msecs)
-  var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
-
-  // Per 4.2.1.2, Bump clockseq on clock regression
-  if (dt < 0 && options.clockseq === undefined) {
-    clockseq = clockseq + 1 & 0x3fff;
-  }
-
-  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
-  // time interval
-  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
-    nsecs = 0;
-  }
 
-  // Per 4.2.1.2 Throw error if too many uuids are requested
-  if (nsecs >= 10000) {
-    throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
-  }
-
-  _lastMSecs = msecs;
-  _lastNSecs = nsecs;
-  _clockseq = clockseq;
-
-  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
-  msecs += 12219292800000;
-
-  // `time_low`
-  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
-  b[i++] = tl >>> 24 & 0xff;
-  b[i++] = tl >>> 16 & 0xff;
-  b[i++] = tl >>> 8 & 0xff;
-  b[i++] = tl & 0xff;
-
-  // `time_mid`
-  var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
-  b[i++] = tmh >>> 8 & 0xff;
-  b[i++] = tmh & 0xff;
-
-  // `time_high_and_version`
-  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
-  b[i++] = tmh >>> 16 & 0xff;
-
-  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
-  b[i++] = clockseq >>> 8 | 0x80;
-
-  // `clock_seq_low`
-  b[i++] = clockseq & 0xff;
-
-  // `node`
-  for (var n = 0; n < 6; ++n) {
-    b[i + n] = node[n];
-  }
-
-  return buf ? buf : bytesToUuid_1(b);
-}
-
-var v1_1 = v1;
-
-function v4(options, buf, offset) {
-  var i = buf && offset || 0;
-
-  if (typeof(options) == 'string') {
-    buf = options === 'binary' ? new Array(16) : null;
-    options = null;
-  }
-  options = options || {};
-
-  var rnds = options.random || (options.rng || rng)();
-
-  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  rnds[6] = (rnds[6] & 0x0f) | 0x40;
-  rnds[8] = (rnds[8] & 0x3f) | 0x80;
-
-  // Copy bytes to buffer, if provided
-  if (buf) {
-    for (var ii = 0; ii < 16; ++ii) {
-      buf[i + ii] = rnds[ii];
-    }
-  }
-
-  return buf || bytesToUuid_1(rnds);
-}
-
-var v4_1 = v4;
-
-var uuid = v4_1;
-uuid.v1 = v1_1;
-uuid.v4 = v4_1;
-
-var uuid_1 = uuid;
+var DocTemplateFacetList = __vue_component__$5;
 
 var toString = Object.prototype.toString;
 
@@ -13360,7 +13283,6 @@ var _typeof = function(object) {
 };
 
 //
-// import safeEval from "notevil";
 
 var script$3 = {
   name: 'DocForm',
@@ -13391,34 +13313,42 @@ var script$3 = {
       default: true
     }
   },
+
   data() {
     return {
       validationState: {}
     };
   },
+
   watch: {
     formConfig() {
       this.validationState = {};
       this.execApplyDefaultValues();
       this.execApplyDefaultValRule();
     }
+
   },
   methods: {
     getResolveValueName(field) {
       if ((field.dict || field.ref) && !field.multiple) {
         return field.name.substring(0, field.name.length - 2);
       }
+
       return field.name;
     },
+
     getResolveValue(field) {
       return this.doc[this.getResolveValueName(field)] ? this.doc[this.getResolveValueName(field)] : null;
     },
-    setResolveValue({
-      field,
-      multiple = false
-    }) {
+
+    setResolveValue(_ref) {
+      let {
+        field,
+        multiple = false
+      } = _ref;
       this.getResolveValue(field);
     },
+
     getDisplayField(value) {
       if (!value[this.displayField]) {
         return value.labelRu;
@@ -13426,16 +13356,20 @@ var script$3 = {
         return value[this.displayField];
       }
     },
+
     onEventFired(eventName, event, field) {
       if (eventName === 'input' && field.ref && !field.multiple) {
         let dataField = null;
+
         if (field.name.lastIndexOf(this.refSuffix) >= 0) {
           dataField = field.name.substring(0, field.name.lastIndexOf(this.refSuffix));
         }
+
         if (dataField && dataField.length > 0) {
           this.doc[dataField] = null;
         }
       }
+
       if (field.rules) {
         field.rules.forEach(rule => {
           if (rule.event === eventName && rule.script) {
@@ -13447,6 +13381,7 @@ var script$3 = {
         });
       }
     },
+
     onGlobalEventFired(eventName, event) {
       let fields = UtFormConfig.getFields(this.formConfig);
       fields.forEach(f => {
@@ -13462,6 +13397,7 @@ var script$3 = {
         }
       });
     },
+
     createRuleContext(additionalContext) {
       return Object.assign({
         form: this,
@@ -13469,58 +13405,81 @@ var script$3 = {
         ...additionalContext
       }, UtFormConstructor.getRuleContext());
     },
+
     runRule(rule, context) {
       UtFormConstructor.runRule(this.createRuleContext(context), rule.script);
     },
+
     isValueEmpty(fieldName) {
+      var _this$doc$fieldName;
+
       if (this.doc[fieldName] == null) {
         return true;
       }
-      if (Array.isArray(this.doc[fieldName]) && !this.doc[fieldName]?.length) {
+
+      if (Array.isArray(this.doc[fieldName]) && !((_this$doc$fieldName = this.doc[fieldName]) !== null && _this$doc$fieldName !== void 0 && _this$doc$fieldName.length)) {
         return true;
       }
+
       if (_typeof(this.doc[fieldName] === 'string') && this.doc[fieldName] === '') {
         return true;
       }
+
       return false;
     },
+
     isValueLessThanMax(fieldname, max) {
       if (this.doc[fieldname] && max) {
-        return this.doc[fieldname]?.length > parseInt(max);
+        var _this$doc$fieldname;
+
+        return ((_this$doc$fieldname = this.doc[fieldname]) === null || _this$doc$fieldname === void 0 ? void 0 : _this$doc$fieldname.length) > parseInt(max);
       }
+
       return false;
     },
+
     isValueLessThanMin(fieldname, min) {
       if (this.doc[fieldname] && min) {
         return parseInt(this.doc[fieldname]) < parseInt(min);
       }
+
       return false;
     },
+
     validate() {
       this.formConfig.sections.forEach(s => {
         s.columns.forEach(c => {
           c.fields.forEach(f => {
+            var _f$input$propsData;
+
             let feedback = '';
+
             if (f.required && this.isValueEmpty(f.name)) {
               feedback += i18n.t('validate.required', {
                 field: this.getDisplayField(f)
               });
             }
+
             if (f.type === 'integer' && this.isValueLessThanMin(f.name, f.input.propsData.min)) {
               feedback += `\n${i18n.t('validate.min', {
                 min: f.input.propsData.min
               })}`;
+            } // TODO: Костыль так как на бэке нету типа memo
+
+
+            if (f.input.type === 'b-form-textarea' && this.isValueLessThanMax(f.name, (_f$input$propsData = f.input.propsData) === null || _f$input$propsData === void 0 ? void 0 : _f$input$propsData.max)) {
+              var _f$input$propsData2;
+
+              feedback += `\nМаксимальное значение для этого поля ${(_f$input$propsData2 = f.input.propsData) === null || _f$input$propsData2 === void 0 ? void 0 : _f$input$propsData2.max}`;
             }
-            // TODO: Костыль так как на бэке нету типа memo
-            if (f.input.type === 'b-form-textarea' && this.isValueLessThanMax(f.name, f.input.propsData?.max)) {
-              feedback += `\nМаксимальное значение для этого поля ${f.input.propsData?.max}`;
-            }
+
             if (feedback) {
               Vue$1.set(this.validationState, f.name, false);
               Vue$1.set(this.validationState, `${f.name}__feedback`, feedback);
             } else {
               Vue$1.set(this.validationState, f.name, null);
             }
+
             this.onEventFired('validate', {
               validationState: this.validationState,
               doc: this.doc
@@ -13528,21 +13487,27 @@ var script$3 = {
           });
         });
       });
+
       for (let fieldName in this.validationState) {
         if (this.validationState[fieldName] === false) {
           return false;
         }
       }
+
       return true;
     },
+
     getColumnSize(section) {
       const MAX_COLUMN_SIZE = 12;
+
       if (!section || !section.columnCount) {
         return MAX_COLUMN_SIZE;
       }
+
       let colSize = Math.floor(MAX_COLUMN_SIZE / section.columnCount);
       return colSize;
     },
+
     execApplyDefaultValues() {
       if (this.applyDefaultValues) {
         this.formConfig.sections.forEach(r => {
@@ -13550,11 +13515,13 @@ var script$3 = {
             c.fields.forEach(f => {
               if (f.defaultValue) {
                 let defValue;
+
                 if (this.defaultValue && _typeof(f.defaultValue) === 'function') {
                   defValue = f.defaultValue();
                 } else {
                   defValue = f.defaultValue == null ? null : f.defaultValue;
                 }
+
                 this.$set(this.doc, f.name, f.defaultValue = defValue);
               }
             });
@@ -13562,6 +13529,7 @@ var script$3 = {
         });
       }
     },
+
     execApplyDefaultValRule() {
       this.formConfig.sections.forEach(el => {
         el.columns.forEach(c => {
@@ -13569,6 +13537,7 @@ var script$3 = {
             if (f.rules) {
               if (!f.defaultValue) {
                 const rule = f.rules.find(rule => rule.event === 'defaultValue');
+
                 if (rule && !this.doc[f.name]) {
                   this.$set(this.doc, f.name, f.defaultValue = eval(rule.script));
                 }
@@ -13578,27 +13547,34 @@ var script$3 = {
         });
       });
     }
+
   },
+
   mounted() {
     this.execApplyDefaultValues();
     this.execApplyDefaultValRule();
     this.onGlobalEventFired('form-mounted', this);
   },
+
   activated() {
     this.execApplyDefaultValues();
     this.execApplyDefaultValRule();
     this.onGlobalEventFired('form-activated', this);
   }
+
 };
 
 /* script */
 const __vue_script__$3 = script$3;
-
 /* template */
+
 var __vue_render__$3 = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _vm.formConfig && _vm.formConfig.sections ? _c('b-form', {
     staticClass: "rb-doc-form",
     on: {
@@ -13696,15 +13672,19 @@ var __vue_render__$3 = function () {
     })], 2)], 1);
   }), 1) : _vm._e();
 };
-var __vue_staticRenderFns__$3 = [];
 
+var __vue_staticRenderFns__$3 = [];
 /* style */
+
 const __vue_inject_styles__$3 = undefined;
 /* scoped */
+
 const __vue_scope_id__$3 = undefined;
 /* module identifier */
+
 const __vue_module_identifier__$3 = undefined;
 /* functional template */
+
 const __vue_is_functional_template__$3 = false;
 /* style inject */
 
@@ -13716,8 +13696,28 @@ const __vue_component__$4 = /*#__PURE__*/normalizeComponent({
   render: __vue_render__$3,
   staticRenderFns: __vue_staticRenderFns__$3
 }, __vue_inject_styles__$3, __vue_script__$3, __vue_scope_id__$3, __vue_is_functional_template__$3, __vue_module_identifier__$3, false, undefined, undefined, undefined);
+
 var DocForm = __vue_component__$4;
 
+const generateRandomString = length => {
+  let result = '';
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  const charactersLength = characters.length;
+
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+
+  return result;
+};
+
+const UtRandom = {
+  getRandomString(length) {
+    return generateRandomString(length);
+  }
+
+};
+
 //
 var script$2 = {
   name: 'FieldRuleFormModal',
@@ -13734,6 +13734,7 @@ var script$2 = {
     },
     onAfterOk: Function
   },
+
   data() {
     return {
       id: 'rb-field-rule-form-modal',
@@ -13742,21 +13743,26 @@ var script$2 = {
       innerRule: null
     };
   },
+
   computed: {
     title() {
       return this.mode === 'ins' ? 'Добавление правила' : 'Редактирование правила';
     },
+
     fields() {
       return UtFormConfig.getFields(this.formConfig);
     },
+
     rulePresets() {
       return UtFormConstructor.getAvailableFieldRules(this.field);
     }
+
   },
   watch: {
     formConfig() {
       this.copyToInnerFormConfig();
     },
+
     rule() {
       if (this.rule) {
         this.innerRule = this.rule;
@@ -13764,6 +13770,7 @@ var script$2 = {
         this.innerRule = this.getDefaultRule();
       }
     }
+
   },
   methods: {
     validateFields(fieldName) {
@@ -13778,14 +13785,18 @@ var script$2 = {
         }
       });
     },
+
     copyToInnerFormConfig() {
       this.innerFormConfig = JSON.parse(JSON.stringify(this.formConfig));
     },
+
     applyRuleToInnerFormConfig() {
       if (this.innerFormConfig) {
         let foundRule = UtFormConfig.findRule(this.innerRule.id, this.innerFormConfig);
+
         if (!foundRule) {
           let foundField = UtFormConfig.findField(this.field.name, this.innerFormConfig);
+
           if (foundField) {
             foundField.rules = foundField.rules ? foundField.rules : [];
             foundField.rules.push(this.rule);
@@ -13795,12 +13806,14 @@ var script$2 = {
         }
       }
     },
+
     onActivateTab(index) {
       if (index > 0) {
         this.copyToInnerFormConfig();
         this.applyRuleToInnerFormConfig();
       }
     },
+
     getDefaultState() {
       return {
         name: null,
@@ -13808,30 +13821,36 @@ var script$2 = {
         script: null
       };
     },
+
     getDefaultRule() {
       return {
-        id: uuid_1.v4(),
+        id: UtRandom.getRandomString(10),
         name: null,
         event: null,
         script: null
       };
     },
+
     resetModal() {
       this.state = this.getDefaultState();
       this.innerRule = null;
     },
+
     addVariableToScript(varName) {
       let caretPosition = this.$refs.scriptInput.selectionStart;
       this.insertTextToScript(varName, caretPosition);
     },
+
     addSetVariableToScript(field) {
       let caretPosition = this.$refs.scriptInput.selectionStart;
       this.insertTextToScript(`doc['${field.name}'] = Значение;`, caretPosition);
     },
+
     addCallInputFunction(field) {
       let caretPosition = this.$refs.scriptInput.selectionStart;
       this.insertTextToScript(`form.$refs['${field.name}'][0].Название функции();`, caretPosition);
     },
+
     insertTextToScript(text, position) {
       position = position != null ? position : this.script.length;
       this.innerRule.script = this.innerRule.script != null ? this.innerRule.script : '';
@@ -13839,39 +13858,50 @@ var script$2 = {
       scriptSplit.splice(position, 0, text);
       this.innerRule.script = scriptSplit.join('');
     },
+
     onRuleSelected(ruleName) {
       let rule = this.rulePresets.find(rule => rule.name === ruleName);
+
       if (rule) {
         Object.assign(this.innerRule, rule);
         this.innerRule.script = this.innerRule.script.trim();
       }
     },
+
     onOk() {
       this.validateFields();
+
       if (this.state.name && this.state.script) {
         if (this.onAfterOk) {
           this.onAfterOk(this.innerRule);
         }
+
         this.$nextTick(() => {
           this.resetModal();
           this.$bvModal.hide(this.id);
         });
       }
     }
+
   },
+
   created() {
     this.copyToInnerFormConfig();
   }
+
 };
 
 /* script */
 const __vue_script__$2 = script$2;
-
 /* template */
+
 var __vue_render__$2 = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _c('b-modal', {
     attrs: {
       "id": _vm.id,
@@ -14124,15 +14154,19 @@ var __vue_render__$2 = function () {
     }
   })], 1) : _vm._e()], 1)], 1)], 1);
 };
-var __vue_staticRenderFns__$2 = [];
 
+var __vue_staticRenderFns__$2 = [];
 /* style */
+
 const __vue_inject_styles__$2 = undefined;
 /* scoped */
+
 const __vue_scope_id__$2 = undefined;
 /* module identifier */
+
 const __vue_module_identifier__$2 = undefined;
 /* functional template */
+
 const __vue_is_functional_template__$2 = false;
 /* style inject */
 
@@ -14144,6 +14178,7 @@ const __vue_component__$3 = /*#__PURE__*/normalizeComponent({
   render: __vue_render__$2,
   staticRenderFns: __vue_staticRenderFns__$2
 }, __vue_inject_styles__$2, __vue_script__$2, __vue_scope_id__$2, __vue_is_functional_template__$2, __vue_module_identifier__$2, false, undefined, undefined, undefined);
+
 var FieldRuleFormModal = __vue_component__$3;
 
 //
@@ -14163,6 +14198,7 @@ var script$1 = {
     },
     formConfig: Object
   },
+
   data() {
     return {
       innerVisible: null,
@@ -14173,64 +14209,81 @@ var script$1 = {
         rule: {},
         mode: 'ins'
       },
-      rulesHash: uuid_1.v4()
+      rulesHash: UtRandom.getRandomString(10)
     };
   },
+
   computed: {
     inputOptions() {
       return this.field ? UtFormConstructor.getInputTypes(this.field) : [];
     },
+
     iconCloseSidebar() {
       return UtFormConstructor.config.icons.iconCloseFieldSidebar;
     },
+
     iconOpenSidebar() {
       return UtFormConstructor.config.icons.iconOpenFieldSidebar;
     },
+
     iconAdd() {
       return UtFormConstructor.config.icons.iconAdd;
     },
+
     rules() {
       return UtFormConstructor.getAvailableFieldRules(this.field);
     },
+
     hasMultipleInputTypes() {
       return UtFormConstructor.hasMultipleInputTypes(this.field);
     },
+
     multiple() {
       return this.field && this.field.multiple;
     }
+
   },
   watch: {
     visible() {
       this.innerVisible = this.visible;
     },
+
     value() {
       this.field = this.value;
+
       if (this.field && this.field.input) {
         this.currentInputName = this.field.input.name;
       }
     },
+
     field: {
       handler() {
         this.$emit('input', this.field);
         this.$emit('change', this.field);
       },
+
       deep: true
     },
+
     currentInputName(val) {
       this.field.input = UtFormConstructor.getInputTypeByName(this.currentInputName, this.field);
     },
+
     multiple() {
       let input = UtFormConstructor.getDefaultInput(this.field);
+
       if (this.field.multiple) {
         this.currentInputName = input.name;
       }
     }
+
   },
   methods: {
     hide() {
       this.innerVisible = false;
       this.$emit('hide');
     },
+
     getPropInputType(prop, propName) {
       if (['string', 'number'].includes(prop.type)) {
         return 'b-form-input';
@@ -14240,6 +14293,7 @@ var script$1 = {
         return 'rb-boolean-single-option-input';
       }
     },
+
     getPropInputPropData(prop, propName) {
       if (prop.type === 'string') {
         return {
@@ -14253,6 +14307,7 @@ var script$1 = {
         return {};
       }
     },
+
     addRule() {
       this.ruleModalCfg = {
         mode: 'ins',
@@ -14262,22 +14317,22 @@ var script$1 = {
         },
         onAfterOk: rule => {
           this.field.rules = this.field.rules ? this.field.rules : [];
-          this.field.rules.push({
-            ...rule
+          this.field.rules.push({ ...rule
           });
-          this.rulesHash = uuid_1.v4();
+          this.rulesHash = UtRandom.getRandomString(10);
         }
       };
       this.$bvModal.show(this.modalId);
     },
+
     editRule(rule, event) {
       if (event.target.classList && event.target.classList.contains('rb-remove-rule')) {
         return;
       }
+
       this.ruleModalCfg = {
         mode: 'upd',
-        rule: {
-          ...rule
+        rule: { ...rule
         },
         onAfterOk: modalRule => {
           Object.assign(rule, modalRule);
@@ -14285,33 +14340,43 @@ var script$1 = {
       };
       this.$bvModal.show(this.modalId);
     },
+
     removeRule(rule) {
       let index = this.field.rules.findIndex(r => r.id === rule.id);
+
       if (index >= 0) {
         this.field.rules.splice(index, 1);
       }
-      this.rulesHash = uuid_1.v4();
+
+      this.rulesHash = UtRandom.getRandomString(10);
     }
+
   },
+
   created() {
     if (this.value) {
       this.innerVisible = this.visible;
       this.field = this.value;
+
       if (this.field && this.field.input) {
         this.currentInputName = this.field.input.name;
       }
     }
   }
+
 };
 
 /* script */
 const __vue_script__$1 = script$1;
-
 /* template */
+
 var __vue_render__$1 = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _c('b-sidebar', {
     staticClass: "rb-doc-template-field-sidebar",
     attrs: {
@@ -14549,15 +14614,19 @@ var __vue_render__$1 = function () {
     }
   })], 1);
 };
-var __vue_staticRenderFns__$1 = [];
 
+var __vue_staticRenderFns__$1 = [];
 /* style */
+
 const __vue_inject_styles__$1 = undefined;
 /* scoped */
+
 const __vue_scope_id__$1 = undefined;
 /* module identifier */
+
 const __vue_module_identifier__$1 = undefined;
 /* functional template */
+
 const __vue_is_functional_template__$1 = false;
 /* style inject */
 
@@ -14569,6 +14638,7 @@ const __vue_component__$2 = /*#__PURE__*/normalizeComponent({
   render: __vue_render__$1,
   staticRenderFns: __vue_staticRenderFns__$1
 }, __vue_inject_styles__$1, __vue_script__$1, __vue_scope_id__$1, __vue_is_functional_template__$1, __vue_module_identifier__$1, false, undefined, undefined, undefined);
+
 var DocTemplateFieldSidebar = __vue_component__$2;
 
 //
@@ -14594,6 +14664,7 @@ var script = {
       default: () => []
     }
   },
+
   data() {
     return {
       sidebarVisible: false,
@@ -14604,32 +14675,41 @@ var script = {
         id: 'rb-doc-template-section-modal',
         mode: 'ins',
         section: null,
+
         onAfterOk() {}
+
       }
     };
   },
+
   computed: {
     iconAdd() {
       return UtFormConstructor.config.icons.iconAdd;
     },
+
     iconEdit() {
       return UtFormConstructor.config.icons.iconEdit;
     },
+
     iconDelete() {
       return UtFormConstructor.config.icons.iconDelete;
     },
+
     iconDrag() {
       return UtFormConstructor.config.icons.iconDrag;
     }
+
   },
   methods: {
     showProperties(field, event) {
       if (event.target.classList && event.target.classList.contains('rb-remove-field')) {
         return;
       }
+
       this.sidebarVisible = true;
       this.sidebarField = field;
     },
+
     addSection(columnCount) {
       let section = {
         labelRu: null,
@@ -14637,24 +14717,32 @@ var script = {
       };
       this.sectionModalCfg.mode = 'ins';
       this.sectionModalCfg.section = section;
+
       this.sectionModalCfg.onAfterOk = () => {
         section.columns = [];
+
         for (let i = 0; i < columnCount; i++) {
           section.columns.push({
             index: i,
             fields: []
           });
         }
+
         this.formConfig.sections.push(section);
       };
+
       this.$bvModal.show(this.sectionModalCfg.id);
     },
+
     editSection(section) {
       this.sectionModalCfg.mode = 'update';
       this.sectionModalCfg.section = section;
+
       this.sectionModalCfg.onAfterOk = () => {};
+
       this.$bvModal.show(this.sectionModalCfg.id);
     },
+
     removeSection(section, index) {
       this.formConfig.sections.splice(index, 1);
       /*UtModal.showYesNoDialog('Вы действительно хотите удалить секцию?', {
@@ -14678,31 +14766,40 @@ var script = {
       });
       return count > 1;
     },
+
     removeFieldFromColumn(field, column, newIndex) {
       let index = newIndex != null ? newIndex : -1;
+
       if (index < 0) {
         index = column.fields.findIndex(f => field.name === f.name);
       }
+
       if (index >= 0) {
         column.fields.splice(index, 1);
       }
     },
+
     onRemoveField(event, field, column) {
       event.preventDefault();
       this.removeFieldFromColumn(field, column);
     },
+
     onFieldAddedToColumn(event, column, section) {
       this.columnTo = column;
     },
+
     onFieldMoveEnd(event) {
       const {
         newIndex
       } = event;
       let field = event.item._underlying_vm_;
+
       if (!field.hasOwnProperty('defaultValue')) {
         this.$set(field, 'defaultValue', undefined);
       }
+
       let found = this.multipleFieldAreOnFormConfig(field);
+
       if (found) {
         this.removeFieldFromColumn(field, this.columnTo, newIndex);
         this.resetDragVariables();
@@ -14716,30 +14813,36 @@ var script = {
           noCloseOnEsc: true
         });
       }
+
       this.resetDragVariables();
       this.hash = (Math.random() + 1).toString(36).substring(7);
     },
+
     getFieldExtendedPropsData(field) {
-      return {
-        ...field.input.propsData,
+      return { ...field.input.propsData,
         placeholder: field.tag,
         disabled: true
       };
     },
+
     resetDragVariables() {
       this.columnTo = null;
     }
+
   }
 };
 
 /* script */
 const __vue_script__ = script;
-
 /* template */
+
 var __vue_render__ = function () {
   var _vm = this;
+
   var _h = _vm.$createElement;
+
   var _c = _vm._self._c || _h;
+
   return _c('div', {
     staticClass: "rb-doc-template-constructor d-flex"
   }, [_c('doc-template-facet-list', {
@@ -14964,15 +15067,19 @@ var __vue_render__ = function () {
     }
   })], 1)], 1);
 };
-var __vue_staticRenderFns__ = [];
 
+var __vue_staticRenderFns__ = [];
 /* style */
+
 const __vue_inject_styles__ = undefined;
 /* scoped */
+
 const __vue_scope_id__ = undefined;
 /* module identifier */
+
 const __vue_module_identifier__ = undefined;
 /* functional template */
+
 const __vue_is_functional_template__ = false;
 /* style inject */
 
@@ -14984,6 +15091,7 @@ const __vue_component__ = /*#__PURE__*/normalizeComponent({
   render: __vue_render__,
   staticRenderFns: __vue_staticRenderFns__
 }, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);
+
 var __vue_component__$1 = __vue_component__;
 
 /* eslint-disable import/prefer-default-export */
@@ -15003,11 +15111,11 @@ var components = /*#__PURE__*/Object.freeze({
 
 // Import vue components
 
-// install function executed by Vue.use()
 const install = function installRbDocumentFormConstructor(Vue) {
-  Object.entries(components).forEach(([componentName, component]) => {
+  Object.entries(components).forEach(_ref => {
+    let [componentName, component] = _ref;
     Vue.component(componentName, component);
   });
-};
+}; // Create module definition for Vue.use()
 
 export { DocForm, __vue_component__$1 as DocTemplateConstructor, DocTemplateFacetList, DocTemplateFieldSidebar, DocTemplateSectionModal, FieldRuleFormModal, UtFormConfig, UtFormConstructor, install as default, i18n };