Add manual toolbox module ordering

website/src/features/toolboxes/storage/toolboxStorage.js

@@ -121,14 +121,70 @@ function normalizeToolboxModule(module) {
   return normalized;
 }
 
+function uniqueKnownIds(ids, knownIds) {
+  const known = new Set(knownIds);
+  const seen = new Set();
+  return (Array.isArray(ids) ? ids : [])
+    .map((id) => String(id || ""))
+    .filter((id) => {
+      if (!known.has(id) || seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    });
+}
+
+function completeModuleOrder(ids, knownIds) {
+  const ordered = uniqueKnownIds(ids, knownIds);
+  const used = new Set(ordered);
+  return [...ordered, ...knownIds.filter((id) => !used.has(id))];
+}
+
+function splitModuleOrder(ids) {
+  const splitIndex = Math.ceil(ids.length / 2);
+  return [ids.slice(0, splitIndex), ids.slice(splitIndex)];
+}
+
+export function normalizeModuleOrder(moduleOrder, modules) {
+  const moduleIds = modules.map((module) => module.id);
+  const one = completeModuleOrder(moduleOrder?.one, moduleIds);
+  const hasTwoColumnOrder = Array.isArray(moduleOrder?.two) && Array.isArray(moduleOrder.two[0]) && Array.isArray(moduleOrder.two[1]);
+  if (!hasTwoColumnOrder) return { one, two: splitModuleOrder(one) };
+
+  const firstColumn = uniqueKnownIds(moduleOrder.two[0], moduleIds);
+  const firstColumnIds = new Set(firstColumn);
+  const secondColumn = uniqueKnownIds(moduleOrder.two[1], moduleIds).filter((id) => !firstColumnIds.has(id));
+  const used = new Set([...firstColumn, ...secondColumn]);
+  const missing = moduleIds.filter((id) => !used.has(id));
+  const two = [firstColumn, secondColumn];
+  missing.forEach((id) => {
+    const targetIndex = two[0].length <= two[1].length ? 0 : 1;
+    two[targetIndex].push(id);
+  });
+  return { one, two };
+}
+
+export function remapModuleOrderIds(moduleOrder, moduleIdMap) {
+  if (!moduleOrder) return null;
+  const remapIds = (ids) => (Array.isArray(ids) ? ids.map((id) => moduleIdMap.get(id)).filter(Boolean) : []);
+  return {
+    one: remapIds(moduleOrder.one),
+    two: [
+      remapIds(moduleOrder.two?.[0]),
+      remapIds(moduleOrder.two?.[1])
+    ]
+  };
+}
+
 export function normalizeToolbox(toolbox) {
   if (!toolbox || typeof toolbox !== "object") return null;
+  const modules = (Array.isArray(toolbox.modules) ? toolbox.modules : []).map(normalizeToolboxModule).filter(Boolean);
   return {
     id: toolbox.id || uid("tbx"),
     name: String(toolbox.name || "Nouvelle toolbox").trim() || "Nouvelle toolbox",
     icon: normalizeToolboxIcon(toolbox.icon),
     moduleColumns: Number(toolbox.moduleColumns) === 1 ? 1 : 2,
-    modules: (Array.isArray(toolbox.modules) ? toolbox.modules : []).map(normalizeToolboxModule).filter(Boolean),
+    modules,
+    moduleOrder: normalizeModuleOrder(toolbox.moduleOrder, modules),
     updatedAt: toolbox.updatedAt || new Date().toISOString()
   };
 }
@@ -140,6 +196,7 @@ export function compactToolboxForStorage(toolbox) {
     id: normalized.id,
     name: normalized.name,
     modules: normalized.modules,
+    moduleOrder: normalized.moduleOrder,
     updatedAt: normalized.updatedAt
   };
   if (normalized.moduleColumns === 1) compact.moduleColumns = 1;
@@ -1413,7 +1470,8 @@ export function createToolboxExportPayload(toolbox, moduleData) {
       const id = nextId("mod");
       moduleIdMap.set(module.id, id);
       return { ...module, id };
-    })
+    }),
+    moduleOrder: remapModuleOrderIds(source.moduleOrder, moduleIdMap)
   });
   const modules = Object.fromEntries(source.modules
     .map((module) => [