@multiplatform.one/backoffice 7.34.3 → 7.35.0

package/dist/cjs/formBuilder/index.cjs

@@ -0,0 +1,68 @@
+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 formBuilder_exports = {};
+__export(formBuilder_exports, {
+  FormBuilderScreen: () => import_FormBuilderScreen.FormBuilderScreen,
+  addColumn: () => import_model.addColumn,
+  addSection: () => import_model.addSection,
+  addTab: () => import_model.addTab,
+  buildCustomizeFormPayload: () => import_api.buildCustomizeFormPayload,
+  buildDoctypeSavePayload: () => import_api.buildDoctypeSavePayload,
+  canDeleteField: () => import_model.canDeleteField,
+  fieldLocation: () => import_model.fieldLocation,
+  fieldsFromLayout: () => import_model.fieldsFromLayout,
+  fieldtypeCatalog: () => import_fieldtypes.fieldtypeCatalog,
+  findField: () => import_model.findField,
+  formBuilderFields: () => import_api.formBuilderFields,
+  formBuilderMode: () => import_api.formBuilderMode,
+  holdsValue: () => import_fieldtypes.holdsValue,
+  insertField: () => import_model.insertField,
+  isBreakType: () => import_fieldtypes.isBreakType,
+  isColumnBreak: () => import_fieldtypes.isColumnBreak,
+  isSectionBreak: () => import_fieldtypes.isSectionBreak,
+  isTabBreak: () => import_fieldtypes.isTabBreak,
+  layoutFromFields: () => import_model.layoutFromFields,
+  loadFormBuilderSource: () => import_api.loadFormBuilderSource,
+  moveField: () => import_model.moveField,
+  moveFieldBy: () => import_model.moveFieldBy,
+  moveFieldToSection: () => import_model.moveFieldToSection,
+  needsOptions: () => import_fieldtypes.needsOptions,
+  newFieldFromType: () => import_model.newFieldFromType,
+  optionsHint: () => import_fieldtypes.optionsHint,
+  parseFormBuilderError: () => import_api.parseFormBuilderError,
+  removeColumn: () => import_model.removeColumn,
+  removeField: () => import_model.removeField,
+  removeSection: () => import_model.removeSection,
+  removeTab: () => import_model.removeTab,
+  saveFormBuilderLayout: () => import_api.saveFormBuilderLayout,
+  scrub: () => import_model.scrub,
+  tabBoard: () => import_model.tabBoard,
+  updateBreak: () => import_model.updateBreak,
+  updateField: () => import_model.updateField,
+  validateLayout: () => import_model.validateLayout
+});
+module.exports = __toCommonJS(formBuilder_exports);
+var import_fieldtypes = require("./fieldtypes.cjs");
+var import_model = require("./model.cjs");
+var import_api = require("./api.cjs");
+var import_FormBuilderScreen = require("./FormBuilderScreen.cjs");

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

@@ -0,0 +1,71 @@
+"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 formBuilder_exports = {};
+__export(formBuilder_exports, {
+  FormBuilderScreen: () => import_FormBuilderScreen.FormBuilderScreen,
+  addColumn: () => import_model.addColumn,
+  addSection: () => import_model.addSection,
+  addTab: () => import_model.addTab,
+  buildCustomizeFormPayload: () => import_api.buildCustomizeFormPayload,
+  buildDoctypeSavePayload: () => import_api.buildDoctypeSavePayload,
+  canDeleteField: () => import_model.canDeleteField,
+  fieldLocation: () => import_model.fieldLocation,
+  fieldsFromLayout: () => import_model.fieldsFromLayout,
+  fieldtypeCatalog: () => import_fieldtypes.fieldtypeCatalog,
+  findField: () => import_model.findField,
+  formBuilderFields: () => import_api.formBuilderFields,
+  formBuilderMode: () => import_api.formBuilderMode,
+  holdsValue: () => import_fieldtypes.holdsValue,
+  insertField: () => import_model.insertField,
+  isBreakType: () => import_fieldtypes.isBreakType,
+  isColumnBreak: () => import_fieldtypes.isColumnBreak,
+  isSectionBreak: () => import_fieldtypes.isSectionBreak,
+  isTabBreak: () => import_fieldtypes.isTabBreak,
+  layoutFromFields: () => import_model.layoutFromFields,
+  loadFormBuilderSource: () => import_api.loadFormBuilderSource,
+  moveField: () => import_model.moveField,
+  moveFieldBy: () => import_model.moveFieldBy,
+  moveFieldToSection: () => import_model.moveFieldToSection,
+  needsOptions: () => import_fieldtypes.needsOptions,
+  newFieldFromType: () => import_model.newFieldFromType,
+  optionsHint: () => import_fieldtypes.optionsHint,
+  parseFormBuilderError: () => import_api.parseFormBuilderError,
+  removeColumn: () => import_model.removeColumn,
+  removeField: () => import_model.removeField,
+  removeSection: () => import_model.removeSection,
+  removeTab: () => import_model.removeTab,
+  saveFormBuilderLayout: () => import_api.saveFormBuilderLayout,
+  scrub: () => import_model.scrub,
+  tabBoard: () => import_model.tabBoard,
+  updateBreak: () => import_model.updateBreak,
+  updateField: () => import_model.updateField,
+  validateLayout: () => import_model.validateLayout
+});
+module.exports = __toCommonJS(formBuilder_exports);
+var import_fieldtypes = require("./fieldtypes.native.js");
+var import_model = require("./model.native.js");
+var import_api = require("./api.native.js");
+var import_FormBuilderScreen = require("./FormBuilderScreen.native.js");
+//# sourceMappingURL=index.native.js.map

package/dist/cjs/formBuilder/index.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","formBuilder_exports","__export","FormBuilderScreen","import_FormBuilderScreen","addColumn","import_model","addSection","addTab","buildCustomizeFormPayload","import_api","buildDoctypeSavePayload","canDeleteField","fieldLocation","fieldsFromLayout","fieldtypeCatalog","import_fieldtypes","findField","formBuilderFields","formBuilderMode","holdsValue","insertField","isBreakType","isColumnBreak","isSectionBreak","isTabBreak","layoutFromFields","loadFormBuilderSource","moveField","moveFieldBy","moveFieldToSection","needsOptions","newFieldFromType","optionsHint","parseFormBuilderError","removeColumn","removeField","removeSection","removeTab","saveFormBuilderLayout","scrub","tabBoard","updateBreak","updateField","validateLayout","module","exports","require"],"sources":["../../../src/formBuilder/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,mBAAA;AAAAC,QAAA,CAAAD,mBAAA;EAAAE,iBAAA,EAAAA,CAAA,KAAAC,wBAAA,CAAAD,iBAAA;EAAAE,SAAA,EAAAA,CAAA,KAAAC,YAAA,CAAAD,SAAA;EAAAE,UAAA,EAAAA,CAAA,KAAAD,YAAA,CAAAC,UAAA;EAAAC,MAAA,EAAAA,CAAA,KAAAF,YAAA,CAAAE,MAAA;EAAAC,yBAAA,EAAAA,CAAA,KAAAC,UAAA,CAAAD,yBAAA;EAAAE,uBAAA,EAAAA,CAAA,KAAAD,UAAA,CAAAC,uBAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAN,YAAA,CAAAM,cAAA;EAAAC,aAAA,EAAAA,CAAA,KAAAP,YAAA,CAAAO,aAAA;EAAAC,gBAAA,EAAAA,CAAA,KAAAR,YAAA,CAAAQ,gBAAA;EAAAC,gBAAA,EAAAA,CAAA,KAAAC,iBAAA,CAAAD,gBAAA;EAAAE,SAAA,EAAAA,CAAA,KAAAX,YAAA,CAAAW,SAAA;EAAAC,iBAAA,EAAAA,CAAA,KAAAR,UAAA,CAAAQ,iBAAA;EAAAC,eAAA,EAAAA,CAAA,KAAAT,UAAA,CAAAS,eAAA;EAAAC,UAAA,EAAAA,CAAA,KAAAJ,iBAAA,CAAAI,UAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAf,YAAA,CAAAe,WAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAN,iBAAA,CAAAM,WAAA;EAAAC,aAAA,EAAAA,CAAA,KAAAP,iBAAA,CAAAO,aAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAR,iBAAA,CAAAQ,cAAA;EAAAC,UAAA,EAAAA,CAAA,KAAAT,iBAAA,CAAAS,UAAA;EAAAC,gBAAA,EAAAA,CAAA,KAAApB,YAAA,CAAAoB,gBAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAAjB,UAAA,CAAAiB,qBAAA;EAAAC,SAAA,EAAAA,CAAA,KAAAtB,YAAA,CAAAsB,SAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAvB,YAAA,CAAAuB,WAAA;EAAAC,kBAAA,EAAAA,CAAA,KAAAxB,YAAA,CAAAwB,kBAAA;EAAAC,YAAA,EAAAA,CAAA,KAAAf,iBAAA,CAAAe,YAAA;EAAAC,gBAAA,EAAAA,CAAA,KAAA1B,YAAA,CAAA0B,gBAAA;EAAAC,WAAA,EAAAA,CAAA,KAAAjB,iBAAA,CAAAiB,WAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAAxB,UAAA,CAAAwB,qBAAA;EAAAC,YAAA,EAAAA,CAAA,KAAA7B,YAAA,CAAA6B,YAAA;EAAAC,WAAA,EAAAA,CAAA,KAAA9B,YAAA,CAAA8B,WAAA;EAAAC,aAAA,EAAAA,CAAA,KAAA/B,YAAA,CAAA+B,aAAA;EAAAC,SAAA,EAAAA,CAAA,KAAAhC,YAAA,CAAAgC,SAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAA7B,UAAA,CAAA6B,qBAAA;EAAAC,KAAA,EAAAA,CAAA,KAAAlC,YAAA,CAAAkC,KAAA;EAAAC,QAAA,EAAAA,CAAA,KAAAnC,YAAA,CAAAmC,QAAA;EAAAC,WAAA,EAAAA,CAAA,KAAApC,YAAA,CAAAoC,WAAA;EAAAC,WAAA,EAAAA,CAAA,KAAArC,YAAA,CAAAqC,WAAA;EAAAC,cAAA,EAAAA,CAAA,KAAAtC,YAAA,CAAAsC;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAlD,YAWO,CAAAK,mBAAA;AACP,IAAAe,iBA+BO,GAAA+B,OAAA;AACP,IAAAzC,YAAA,GAWOyC,OAAA;AAEP,IAAArC,UAAA,GAAAqC,OAAA,kBAA+D","ignoreList":[]}

package/dist/cjs/formBuilder/model.cjs

@@ -0,0 +1,466 @@
+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.cjs");
+function nodes(layout) {
+  return layout.tabs.flatMap(tab => [tab, ...tab.sections.flatMap(section => [section, ...section.columns.flatMap(column => [column, ...column.fields])])]);
+}
+function keyFactory(layout) {
+  const used = new Set(nodes(layout).map(node => node.key));
+  let next = 1;
+  return () => {
+    while (used.has(`builder_${next}`)) next++;
+    const 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) {
+  const layout = {
+    tabs: []
+  };
+  const key = keyFactory(layout);
+  let tab = emptyTab(key);
+  layout.tabs.push(tab);
+  let section = tab.sections[0];
+  let column = section.columns[0];
+  const ordered = fields.map((df, index) => ({
+    df,
+    index
+  })).sort((a, b) => (a.df.idx ?? a.index + 1) - (b.df.idx ?? b.index + 1));
+  for (const [position, original] of ordered.entries()) {
+    const 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
+      });
+    }
+  }
+  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(n => n.key !== exceptKey).flatMap(n => n.df?.fieldname ? [n.df.fieldname] : []));
+}
+function uniqueName(base, used, numbered = false) {
+  let candidate = base;
+  let n = 1;
+  if (numbered) candidate = `${base}_${n++}`;
+  while (used.has(candidate)) candidate = `${base}_${n++}`;
+  used.add(candidate);
+  return candidate;
+}
+function fieldsFromLayout(layout) {
+  const used = fieldnames(layout);
+  const fields = [];
+  const emit = df => fields.push({
+    ...df,
+    idx: fields.length + 1
+  });
+  const emitBreak = (node, type, needed) => {
+    if (node.df) emit(node.df);else if (needed) emit({
+      fieldtype: type,
+      fieldname: uniqueName(scrub(type), used, true)
+    });
+  };
+  layout.tabs.forEach((tab, ti) => {
+    if (ti > 0 && !tab.sections.some(s => s.columns.some(c => c.fields.length))) return;
+    emitBreak(tab, "Tab Break", ti > 0);
+    tab.sections.forEach((section, si) => {
+      if (!section.columns.some(c => c.fields.length)) return;
+      emitBreak(section, "Section Break", si > 0);
+      section.columns.forEach((column, ci) => {
+        emitBreak(column, "Column Break", ci > 0 || column.fields.length === 0);
+        column.fields.forEach(field => emit(field.df));
+      });
+    });
+  });
+  return fields;
+}
+function copy(layout) {
+  return {
+    tabs: layout.tabs.map(tab => ({
+      ...tab,
+      sections: tab.sections.map(section => ({
+        ...section,
+        columns: section.columns.map(column => ({
+          ...column,
+          fields: [...column.fields]
+        }))
+      }))
+    }))
+  };
+}
+function columns(layout) {
+  return layout.tabs.flatMap(t => t.sections.flatMap(s => s.columns));
+}
+function getColumn(layout, key) {
+  return columns(layout).find(c => c.key === key);
+}
+function findField(layout, key) {
+  return columns(layout).flatMap(c => c.fields).find(field => field.key === key);
+}
+function fieldLocation(layout, key) {
+  for (const tab of layout.tabs) for (const section of tab.sections) for (const column of section.columns) {
+    const index = column.fields.findIndex(f => f.key === key);
+    if (index >= 0) return {
+      tabKey: tab.key,
+      sectionKey: section.key,
+      columnKey: column.key,
+      index
+    };
+  }
+  return void 0;
+}
+function moveField(layout, fieldKey, target) {
+  const from = fieldLocation(layout, fieldKey);
+  if (!from || !getColumn(layout, target.columnId)) return layout;
+  const next = copy(layout);
+  const [field] = getColumn(next, from.columnKey).fields.splice(from.index, 1);
+  const 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) {
+  const label = import_fieldtypes.fieldtypeCatalog.find(f => f.fieldtype === fieldtype)?.label ?? 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");
+  const key = keyFactory(layout);
+  const field = "df" in draft && typeof draft.key === "string" ? {
+    ...draft,
+    key: key(),
+    df: {
+      ...draft.df
+    },
+    isNew: true
+  } : {
+    key: key(),
+    df: {
+      ...draft
+    },
+    isNew: true
+  };
+  const next = copy(layout);
+  if ((0, import_fieldtypes.isBreakType)(field.df.fieldtype)) {
+    const tab = next.tabs.find(t => t.sections.some(s => s.columns.some(c => c.key === target.columnId)));
+    const section = tab.sections.find(s => s.columns.some(c => 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(c => c.key === target.columnId) + 1, 0, {
+        key: field.key,
+        df: field.df,
+        fields: []
+      });
+    }
+  } else {
+    const 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) {
+  const location = fieldLocation(layout, key);
+  if (!location) return layout;
+  const next = copy(layout);
+  getColumn(next, location.columnKey).fields.splice(location.index, 1);
+  return next;
+}
+function updateField(layout, key, patch) {
+  const location = fieldLocation(layout, key);
+  if (!location) return layout;
+  const next = copy(layout);
+  const column = getColumn(next, location.columnKey);
+  const field = column.fields[location.index];
+  const df = {
+    ...field.df,
+    ...patch
+  };
+  const 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)) {
+    const nextKey = keyFactory(layout);
+    const tab = next.tabs.find(t => t.key === location.tabKey);
+    const section = tab.sections.find(s => s.key === location.sectionKey);
+    const ci = section.columns.indexOf(column);
+    const 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 {
+      const remainingColumns = [{
+        key: nextKey(),
+        fields: following
+      }, ...section.columns.splice(ci + 1)];
+      const 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) {
+  const location = fieldLocation(layout, key);
+  if (!location) return layout;
+  const tab = layout.tabs.find(t => t.key === location.tabKey);
+  const ordered = tab.sections.flatMap(s => s.columns);
+  const ci = ordered.findIndex(c => c.key === location.columnKey);
+  const index = location.index + direction;
+  if (index >= 0 && index < ordered[ci].fields.length) return moveField(layout, key, {
+    columnId: location.columnKey,
+    index
+  });
+  const 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) {
+  const column = layout.tabs.flatMap(t => t.sections).find(s => s.key === sectionKey)?.columns[0];
+  if (!column) return layout;
+  return moveField(layout, key, {
+    columnId: column.key,
+    index: column.fields.length
+  });
+}
+function addTab(layout) {
+  const next = copy(layout);
+  next.tabs.push(emptyTab(keyFactory(layout)));
+  return next;
+}
+function addSection(layout, tabKey, afterSectionKey) {
+  const next = copy(layout);
+  const tab = next.tabs.find(t => t.key === tabKey);
+  if (!tab) return layout;
+  const after = afterSectionKey === void 0 ? tab.sections.length - 1 : tab.sections.findIndex(s => 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) {
+  const next = copy(layout);
+  const section = next.tabs.flatMap(t => t.sections).find(s => s.key === sectionKey);
+  if (!section) return layout;
+  section.columns.push(emptyColumn(keyFactory(layout)));
+  return next;
+}
+function removeTab(layout, key) {
+  const index = layout.tabs.findIndex(t => t.key === key);
+  if (index < 0 || layout.tabs.length === 1) return layout;
+  const next = copy(layout);
+  const [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) {
+  const ti = layout.tabs.findIndex(t => t.sections.some(s => s.key === key));
+  if (ti < 0 || layout.tabs.length === 1 && layout.tabs[ti].sections.length === 1) return layout;
+  const next = copy(layout);
+  const tab = next.tabs[ti];
+  const si = tab.sections.findIndex(s => s.key === key);
+  const [section] = tab.sections.splice(si, 1);
+  let previous = si > 0;
+  let dest = tab.sections[previous ? si - 1 : 0];
+  if (!dest) {
+    next.tabs.splice(ti, 1);
+    previous = ti > 0;
+    const neighbour = next.tabs[previous ? ti - 1 : 0];
+    dest = neighbour.sections[previous ? neighbour.sections.length - 1 : 0];
+  }
+  const column = dest.columns[previous ? dest.columns.length - 1 : 0];
+  const fields = section.columns.flatMap(c => c.fields);
+  if (previous) column.fields.push(...fields);else column.fields.unshift(...fields);
+  return next;
+}
+function removeColumn(layout, key) {
+  const next = copy(layout);
+  const section = next.tabs.flatMap(t => t.sections).find(s => s.columns.some(c => c.key === key));
+  if (!section || section.columns.length === 1) return layout;
+  const index = section.columns.findIndex(c => c.key === key);
+  const [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) {
+  const next = copy(layout);
+  const node = nodes(next).find(n => n.key === key);
+  if (!node || "isNew" in node || !("sections" in node || "columns" in node || "fields" in node)) return layout;
+  const fieldtype = "sections" in node ? "Tab Break" : "columns" in node ? "Section Break" : "Column Break";
+  node.df = {
+    ...(node.df ?? {
+      fieldtype,
+      fieldname: uniqueName(scrub(fieldtype), fieldnames(layout), true)
+    }),
+    ...patch,
+    fieldtype
+  };
+  return next;
+}
+function tabBoard(layout, tabKey, columnTitle) {
+  return (layout.tabs.find(t => t.key === tabKey)?.sections.flatMap(s => s.columns) ?? []).map((column, index) => ({
+    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) {
+  const errors = {};
+  const entries = nodes(layout).filter(n => n.df);
+  const counts = /* @__PURE__ */new Map();
+  for (const node of entries) if (node.df?.fieldname) counts.set(node.df.fieldname, (counts.get(node.df.fieldname) ?? 0) + 1);
+  for (const node of entries) {
+    const df = node.df;
+    const add = (key, text) => (errors[node.key] ??= []).push({
+      key: `formBuilder.validation.${key}`,
+      default: text
+    });
+    if ((0, import_fieldtypes.holdsValue)(df.fieldtype) && !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.get(df.fieldname) ?? 0) > 1) add("duplicateFieldname", "Fieldnames must be unique.");
+    if (!df.label?.trim() && !df.fieldname?.trim()) add("labelRequired", "A label or fieldname is required.");
+    if ((0, import_fieldtypes.needsOptions)(df.fieldtype) && !df.options?.trim()) add("optionsRequired", "Options are required for this field type.");
+  }
+  return errors;
+}