@multiplatform.one/backoffice 7.34.4 → 7.36.0

package/dist/cjs/formBuilder/model.native.js

@@ -0,0 +1,714 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var model_exports = {};
+__export(model_exports, {
+  addColumn: () => addColumn,
+  addSection: () => addSection,
+  addTab: () => addTab,
+  canDeleteField: () => canDeleteField,
+  fieldLocation: () => fieldLocation,
+  fieldsFromLayout: () => fieldsFromLayout,
+  findField: () => findField,
+  insertField: () => insertField,
+  layoutFromFields: () => layoutFromFields,
+  moveField: () => moveField,
+  moveFieldBy: () => moveFieldBy,
+  moveFieldToSection: () => moveFieldToSection,
+  newFieldFromType: () => newFieldFromType,
+  removeColumn: () => removeColumn,
+  removeField: () => removeField,
+  removeSection: () => removeSection,
+  removeTab: () => removeTab,
+  scrub: () => scrub,
+  tabBoard: () => tabBoard,
+  updateBreak: () => updateBreak,
+  updateField: () => updateField,
+  validateLayout: () => validateLayout
+});
+module.exports = __toCommonJS(model_exports);
+var import_fieldtypes = require("./fieldtypes.native.js");
+function nodes(layout) {
+  return layout.tabs.flatMap(function (tab) {
+    return [tab, ...tab.sections.flatMap(function (section) {
+      return [section, ...section.columns.flatMap(function (column) {
+        return [column, ...column.fields];
+      })];
+    })];
+  });
+}
+function keyFactory(layout) {
+  var used = new Set(nodes(layout).map(function (node) {
+    return node.key;
+  }));
+  var next = 1;
+  return function () {
+    while (used.has(`builder_${next}`)) next++;
+    var key = `builder_${next++}`;
+    used.add(key);
+    return key;
+  };
+}
+function emptyColumn(key) {
+  return {
+    key: key(),
+    fields: []
+  };
+}
+function emptySection(key) {
+  return {
+    key: key(),
+    columns: [emptyColumn(key)]
+  };
+}
+function emptyTab(key) {
+  return {
+    key: key(),
+    sections: [emptySection(key)]
+  };
+}
+function layoutFromFields(fields) {
+  var layout = {
+    tabs: []
+  };
+  var key = keyFactory(layout);
+  var tab = emptyTab(key);
+  layout.tabs.push(tab);
+  var section = tab.sections[0];
+  var column = section.columns[0];
+  var ordered = fields.map(function (df2, index) {
+    return {
+      df: df2,
+      index
+    };
+  }).sort(function (a, b) {
+    var _a_df_idx, _b_df_idx;
+    return ((_a_df_idx = a.df.idx) !== null && _a_df_idx !== void 0 ? _a_df_idx : a.index + 1) - ((_b_df_idx = b.df.idx) !== null && _b_df_idx !== void 0 ? _b_df_idx : b.index + 1);
+  });
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = ordered.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var [position, original] = _step.value;
+      var df = {
+        ...original.df
+      };
+      if ((0, import_fieldtypes.isTabBreak)(df.fieldtype)) {
+        if (position !== 0 || tab.df) {
+          tab = emptyTab(key);
+          layout.tabs.push(tab);
+        }
+        tab.df = df;
+        section = tab.sections[0];
+        column = section.columns[0];
+      } else if ((0, import_fieldtypes.isSectionBreak)(df.fieldtype)) {
+        if (section.df || section.columns.length > 1 || column.fields.length > 0) {
+          section = emptySection(key);
+          tab.sections.push(section);
+        }
+        section.df = df;
+        column = section.columns[0];
+      } else if ((0, import_fieldtypes.isColumnBreak)(df.fieldtype)) {
+        if (column.df || column.fields.length > 0) {
+          column = emptyColumn(key);
+          section.columns.push(column);
+        }
+        column.df = df;
+      } else {
+        column.fields.push({
+          key: key(),
+          df
+        });
+      }
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  return layout;
+}
+function scrub(text) {
+  return text.toLowerCase().replace(/[ -]/g, "_").replace(/[^a-z0-9_]/g, "");
+}
+function fieldnames(layout, exceptKey) {
+  return new Set(nodes(layout).filter(function (n) {
+    return n.key !== exceptKey;
+  }).flatMap(function (n) {
+    var _n_df;
+    return ((_n_df = n.df) === null || _n_df === void 0 ? void 0 : _n_df.fieldname) ? [n.df.fieldname] : [];
+  }));
+}
+function uniqueName(base, used) {
+  var numbered = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  var candidate = base;
+  var n = 1;
+  if (numbered) candidate = `${base}_${n++}`;
+  while (used.has(candidate)) candidate = `${base}_${n++}`;
+  used.add(candidate);
+  return candidate;
+}
+function fieldsFromLayout(layout) {
+  var used = fieldnames(layout);
+  var fields = [];
+  var emit = function emit2(df) {
+    return fields.push({
+      ...df,
+      idx: fields.length + 1
+    });
+  };
+  var emitBreak = function emitBreak2(node, type, needed) {
+    if (node.df) emit(node.df);else if (needed) emit({
+      fieldtype: type,
+      fieldname: uniqueName(scrub(type), used, true)
+    });
+  };
+  layout.tabs.forEach(function (tab, ti) {
+    if (ti > 0 && !tab.sections.some(function (s) {
+      return s.columns.some(function (c) {
+        return c.fields.length;
+      });
+    })) return;
+    emitBreak(tab, "Tab Break", ti > 0);
+    tab.sections.forEach(function (section, si) {
+      if (!section.columns.some(function (c) {
+        return c.fields.length;
+      })) return;
+      emitBreak(section, "Section Break", si > 0);
+      section.columns.forEach(function (column, ci) {
+        emitBreak(column, "Column Break", ci > 0 || column.fields.length === 0);
+        column.fields.forEach(function (field) {
+          return emit(field.df);
+        });
+      });
+    });
+  });
+  return fields;
+}
+function copy(layout) {
+  return {
+    tabs: layout.tabs.map(function (tab) {
+      return {
+        ...tab,
+        sections: tab.sections.map(function (section) {
+          return {
+            ...section,
+            columns: section.columns.map(function (column) {
+              return {
+                ...column,
+                fields: [...column.fields]
+              };
+            })
+          };
+        })
+      };
+    })
+  };
+}
+function columns(layout) {
+  return layout.tabs.flatMap(function (t) {
+    return t.sections.flatMap(function (s) {
+      return s.columns;
+    });
+  });
+}
+function getColumn(layout, key) {
+  return columns(layout).find(function (c) {
+    return c.key === key;
+  });
+}
+function findField(layout, key) {
+  return columns(layout).flatMap(function (c) {
+    return c.fields;
+  }).find(function (field) {
+    return field.key === key;
+  });
+}
+function fieldLocation(layout, key) {
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0,
+    _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0,
+    _iteratorNormalCompletion2 = true,
+    _didIteratorError2 = false,
+    _iteratorError2 = void 0;
+  try {
+    for (var _iterator = layout.tabs[Symbol.iterator](), _step; !(_iteratorNormalCompletion2 = (_step = _iterator.next()).done); _iteratorNormalCompletion2 = true) {
+      var tab = _step.value;
+      try {
+        for (var _iterator1 = tab.sections[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+          var section = _step1.value;
+          try {
+            for (var _iterator2 = section.columns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion = true) {
+              var column = _step2.value;
+              var index = column.fields.findIndex(function (f) {
+                return f.key === key;
+              });
+              if (index >= 0) return {
+                tabKey: tab.key,
+                sectionKey: section.key,
+                columnKey: column.key,
+                index
+              };
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator2.return != null) {
+                _iterator2.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+            _iterator1.return();
+          }
+        } finally {
+          if (_didIteratorError1) {
+            throw _iteratorError1;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _didIteratorError2 = true;
+    _iteratorError2 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion2 && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError2) {
+        throw _iteratorError2;
+      }
+    }
+  }
+  return void 0;
+}
+function moveField(layout, fieldKey, target) {
+  var from = fieldLocation(layout, fieldKey);
+  if (!from || !getColumn(layout, target.columnId)) return layout;
+  var next = copy(layout);
+  var [field] = getColumn(next, from.columnKey).fields.splice(from.index, 1);
+  var dest = getColumn(next, target.columnId);
+  dest.fields.splice(Math.max(0, Math.min(target.index, dest.fields.length)), 0, field);
+  return next;
+}
+function newFieldFromType(layout, fieldtype) {
+  var _ref;
+  var _fieldtypeCatalog_find;
+  var label = (_ref = (_fieldtypeCatalog_find = import_fieldtypes.fieldtypeCatalog.find(function (f) {
+    return f.fieldtype === fieldtype;
+  })) === null || _fieldtypeCatalog_find === void 0 ? void 0 : _fieldtypeCatalog_find.label) !== null && _ref !== void 0 ? _ref : fieldtype;
+  return {
+    key: keyFactory(layout)(),
+    df: {
+      fieldtype,
+      label,
+      fieldname: uniqueName(scrub(label), fieldnames(layout), (0, import_fieldtypes.isBreakType)(fieldtype))
+    },
+    isNew: true
+  };
+}
+function insertField(layout, draft, target) {
+  if (!getColumn(layout, target.columnId)) throw new Error("Unknown form builder column");
+  var key = keyFactory(layout);
+  var field = "df" in draft && typeof draft.key === "string" ? {
+    ...draft,
+    key: key(),
+    df: {
+      ...draft.df
+    },
+    isNew: true
+  } : {
+    key: key(),
+    df: {
+      ...draft
+    },
+    isNew: true
+  };
+  var next = copy(layout);
+  if ((0, import_fieldtypes.isBreakType)(field.df.fieldtype)) {
+    var tab = next.tabs.find(function (t) {
+      return t.sections.some(function (s) {
+        return s.columns.some(function (c) {
+          return c.key === target.columnId;
+        });
+      });
+    });
+    var section = tab.sections.find(function (s) {
+      return s.columns.some(function (c) {
+        return c.key === target.columnId;
+      });
+    });
+    if ((0, import_fieldtypes.isTabBreak)(field.df.fieldtype)) {
+      next.tabs.splice(next.tabs.indexOf(tab) + 1, 0, {
+        key: field.key,
+        df: field.df,
+        sections: [emptySection(key)]
+      });
+    } else if ((0, import_fieldtypes.isSectionBreak)(field.df.fieldtype)) {
+      tab.sections.splice(tab.sections.indexOf(section) + 1, 0, {
+        key: field.key,
+        df: field.df,
+        columns: [emptyColumn(key)]
+      });
+    } else {
+      section.columns.splice(section.columns.findIndex(function (c) {
+        return c.key === target.columnId;
+      }) + 1, 0, {
+        key: field.key,
+        df: field.df,
+        fields: []
+      });
+    }
+  } else {
+    var column = getColumn(next, target.columnId);
+    column.fields.splice(Math.max(0, Math.min(target.index, column.fields.length)), 0, field);
+  }
+  return {
+    layout: next,
+    key: field.key
+  };
+}
+function removeField(layout, key) {
+  var location = fieldLocation(layout, key);
+  if (!location) return layout;
+  var next = copy(layout);
+  getColumn(next, location.columnKey).fields.splice(location.index, 1);
+  return next;
+}
+function updateField(layout, key, patch) {
+  var location = fieldLocation(layout, key);
+  if (!location) return layout;
+  var next = copy(layout);
+  var column = getColumn(next, location.columnKey);
+  var field = column.fields[location.index];
+  var df = {
+    ...field.df,
+    ...patch
+  };
+  var fieldnameEdited = field.fieldnameEdited || Object.hasOwn(patch, "fieldname");
+  if (field.isNew && !fieldnameEdited && patch.label !== void 0) df.fieldname = uniqueName(scrub(patch.label), fieldnames(layout, key));
+  if ((0, import_fieldtypes.isBreakType)(df.fieldtype)) {
+    var nextKey = keyFactory(layout);
+    var tab = next.tabs.find(function (t) {
+      return t.key === location.tabKey;
+    });
+    var section = tab.sections.find(function (s) {
+      return s.key === location.sectionKey;
+    });
+    var ci = section.columns.indexOf(column);
+    var following = column.fields.splice(location.index);
+    following.shift();
+    if ((0, import_fieldtypes.isColumnBreak)(df.fieldtype)) {
+      section.columns.splice(ci + 1, 0, {
+        key,
+        df,
+        fields: following
+      });
+    } else {
+      var remainingColumns = [{
+        key: nextKey(),
+        fields: following
+      }, ...section.columns.splice(ci + 1)];
+      var si = tab.sections.indexOf(section);
+      if ((0, import_fieldtypes.isSectionBreak)(df.fieldtype)) {
+        tab.sections.splice(si + 1, 0, {
+          key,
+          df,
+          columns: remainingColumns
+        });
+      } else {
+        next.tabs.splice(next.tabs.indexOf(tab) + 1, 0, {
+          key,
+          df,
+          sections: [{
+            key: nextKey(),
+            columns: remainingColumns
+          }, ...tab.sections.splice(si + 1)]
+        });
+      }
+    }
+    return next;
+  }
+  column.fields[location.index] = {
+    ...field,
+    df,
+    ...(fieldnameEdited ? {
+      fieldnameEdited: true
+    } : {})
+  };
+  return next;
+}
+function moveFieldBy(layout, key, direction) {
+  var location = fieldLocation(layout, key);
+  if (!location) return layout;
+  var tab = layout.tabs.find(function (t) {
+    return t.key === location.tabKey;
+  });
+  var ordered = tab.sections.flatMap(function (s) {
+    return s.columns;
+  });
+  var ci = ordered.findIndex(function (c) {
+    return c.key === location.columnKey;
+  });
+  var index = location.index + direction;
+  if (index >= 0 && index < ordered[ci].fields.length) return moveField(layout, key, {
+    columnId: location.columnKey,
+    index
+  });
+  var dest = ordered[ci + direction];
+  return dest ? moveField(layout, key, {
+    columnId: dest.key,
+    index: direction < 0 ? dest.fields.length : 0
+  }) : layout;
+}
+function moveFieldToSection(layout, key, sectionKey) {
+  var _layout_tabs_flatMap_find;
+  var column = (_layout_tabs_flatMap_find = layout.tabs.flatMap(function (t) {
+    return t.sections;
+  }).find(function (s) {
+    return s.key === sectionKey;
+  })) === null || _layout_tabs_flatMap_find === void 0 ? void 0 : _layout_tabs_flatMap_find.columns[0];
+  if (!column) return layout;
+  return moveField(layout, key, {
+    columnId: column.key,
+    index: column.fields.length
+  });
+}
+function addTab(layout) {
+  var next = copy(layout);
+  next.tabs.push(emptyTab(keyFactory(layout)));
+  return next;
+}
+function addSection(layout, tabKey, afterSectionKey) {
+  var next = copy(layout);
+  var tab = next.tabs.find(function (t) {
+    return t.key === tabKey;
+  });
+  if (!tab) return layout;
+  var after = afterSectionKey === void 0 ? tab.sections.length - 1 : tab.sections.findIndex(function (s) {
+    return s.key === afterSectionKey;
+  });
+  if (afterSectionKey !== void 0 && after < 0) return layout;
+  tab.sections.splice(after + 1, 0, emptySection(keyFactory(layout)));
+  return next;
+}
+function addColumn(layout, sectionKey) {
+  var next = copy(layout);
+  var section = next.tabs.flatMap(function (t) {
+    return t.sections;
+  }).find(function (s) {
+    return s.key === sectionKey;
+  });
+  if (!section) return layout;
+  section.columns.push(emptyColumn(keyFactory(layout)));
+  return next;
+}
+function removeTab(layout, key) {
+  var index = layout.tabs.findIndex(function (t) {
+    return t.key === key;
+  });
+  if (index < 0 || layout.tabs.length === 1) return layout;
+  var next = copy(layout);
+  var [removed] = next.tabs.splice(index, 1);
+  if (index > 0) next.tabs[index - 1].sections.push(...removed.sections);else next.tabs[0].sections.unshift(...removed.sections);
+  return next;
+}
+function removeSection(layout, key) {
+  var ti = layout.tabs.findIndex(function (t) {
+    return t.sections.some(function (s) {
+      return s.key === key;
+    });
+  });
+  if (ti < 0 || layout.tabs.length === 1 && layout.tabs[ti].sections.length === 1) return layout;
+  var next = copy(layout);
+  var tab = next.tabs[ti];
+  var si = tab.sections.findIndex(function (s) {
+    return s.key === key;
+  });
+  var [section] = tab.sections.splice(si, 1);
+  var previous = si > 0;
+  var dest = tab.sections[previous ? si - 1 : 0];
+  if (!dest) {
+    next.tabs.splice(ti, 1);
+    previous = ti > 0;
+    var neighbour = next.tabs[previous ? ti - 1 : 0];
+    dest = neighbour.sections[previous ? neighbour.sections.length - 1 : 0];
+  }
+  var column = dest.columns[previous ? dest.columns.length - 1 : 0];
+  var fields = section.columns.flatMap(function (c) {
+    return c.fields;
+  });
+  if (previous) column.fields.push(...fields);else column.fields.unshift(...fields);
+  return next;
+}
+function removeColumn(layout, key) {
+  var next = copy(layout);
+  var section = next.tabs.flatMap(function (t) {
+    return t.sections;
+  }).find(function (s) {
+    return s.columns.some(function (c) {
+      return c.key === key;
+    });
+  });
+  if (!section || section.columns.length === 1) return layout;
+  var index = section.columns.findIndex(function (c) {
+    return c.key === key;
+  });
+  var [column] = section.columns.splice(index, 1);
+  if (index > 0) section.columns[index - 1].fields.push(...column.fields);else section.columns[0].fields.unshift(...column.fields);
+  return next;
+}
+function updateBreak(layout, key, patch) {
+  var _node_df;
+  var next = copy(layout);
+  var node = nodes(next).find(function (n) {
+    return n.key === key;
+  });
+  if (!node || "isNew" in node || !("sections" in node || "columns" in node || "fields" in node)) return layout;
+  var fieldtype = "sections" in node ? "Tab Break" : "columns" in node ? "Section Break" : "Column Break";
+  node.df = {
+    ...((_node_df = node.df) !== null && _node_df !== void 0 ? _node_df : {
+      fieldtype,
+      fieldname: uniqueName(scrub(fieldtype), fieldnames(layout), true)
+    }),
+    ...patch,
+    fieldtype
+  };
+  return next;
+}
+function tabBoard(layout, tabKey, columnTitle) {
+  var _ref;
+  var _layout_tabs_find;
+  return ((_ref = (_layout_tabs_find = layout.tabs.find(function (t) {
+    return t.key === tabKey;
+  })) === null || _layout_tabs_find === void 0 ? void 0 : _layout_tabs_find.sections.flatMap(function (s) {
+    return s.columns;
+  })) !== null && _ref !== void 0 ? _ref : []).map(function (column, index) {
+    return {
+      id: column.key,
+      title: columnTitle(column, index),
+      count: column.fields.length
+    };
+  });
+}
+function canDeleteField(field, mode) {
+  return mode === "doctype" || !!field.isNew || field.df.is_custom_field === 1;
+}
+function validateLayout(layout) {
+  var _counts_get;
+  var _node_df;
+  var errors = {};
+  var entries = nodes(layout).filter(function (n) {
+    return n.df;
+  });
+  var counts = /* @__PURE__ */new Map();
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var node = _step.value;
+      if ((_node_df = node.df) === null || _node_df === void 0 ? void 0 : _node_df.fieldname) counts.set(node.df.fieldname, ((_counts_get = counts.get(node.df.fieldname)) !== null && _counts_get !== void 0 ? _counts_get : 0) + 1);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+  var _iteratorNormalCompletion1 = true,
+    _didIteratorError1 = false,
+    _iteratorError1 = void 0;
+  try {
+    var _loop = function () {
+      var node2 = _step1.value;
+      var _counts_get2;
+      var _df_fieldname, _df_label, _df_fieldname1, _df_options;
+      var df = node2.df;
+      var add = function add2(key, text) {
+        var _errors, _node_key, _;
+        return ((_ = (_errors = errors)[_node_key = node2.key]) !== null && _ !== void 0 ? _ : _errors[_node_key] = []).push({
+          key: `formBuilder.validation.${key}`,
+          default: text
+        });
+      };
+      if ((0, import_fieldtypes.holdsValue)(df.fieldtype) && !((_df_fieldname = df.fieldname) === null || _df_fieldname === void 0 ? void 0 : _df_fieldname.trim())) add("fieldnameRequired", "A fieldname is required.");
+      if (df.fieldname && !/^[a-z][a-z0-9_]*$/.test(df.fieldname)) add("invalidFieldname", "Use lowercase letters, digits and underscores, starting with a letter.");
+      if (df.fieldname && ((_counts_get2 = counts.get(df.fieldname)) !== null && _counts_get2 !== void 0 ? _counts_get2 : 0) > 1) add("duplicateFieldname", "Fieldnames must be unique.");
+      if (!((_df_label = df.label) === null || _df_label === void 0 ? void 0 : _df_label.trim()) && !((_df_fieldname1 = df.fieldname) === null || _df_fieldname1 === void 0 ? void 0 : _df_fieldname1.trim())) add("labelRequired", "A label or fieldname is required.");
+      if ((0, import_fieldtypes.needsOptions)(df.fieldtype) && !((_df_options = df.options) === null || _df_options === void 0 ? void 0 : _df_options.trim())) add("optionsRequired", "Options are required for this field type.");
+    };
+    for (var _iterator1 = entries[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) _loop();
+  } catch (err) {
+    _didIteratorError1 = true;
+    _iteratorError1 = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+        _iterator1.return();
+      }
+    } finally {
+      if (_didIteratorError1) {
+        throw _iteratorError1;
+      }
+    }
+  }
+  return errors;
+}
+//# sourceMappingURL=model.native.js.map