Variant pack: parameter table, sizes and library bodies

/** The parameter table: a column for every driving parameter any chosen configuration sets (the part's order), and for each
 * variant the value it ends up with. `variants[i].built` is the applied copy (variantPart); without it the row's own values. */
export function variantTable(part, variants) {
  const set = new Set();
  for (const v of variants) for (const k of Object.keys(v.row.values)) set.add(k);
  const columns = (part.params?.vars || []).filter((x) => set.has(x.name)).map((x) => ({ key: x.name }));
  for (const k of set) if (!columns.some((c) => c.key === k)) columns.push({ key: k });
  const rows = variants.map((v) => {
    const vals = v.built?.params ? PR.evaluateVars(v.built.params).values : null;
    const values = {};
    for (const c of columns) {
      const x = vals ? vals.get(c.key) : v.row.values[c.key];
      values[c.key] = Number.isFinite(x) ? Number(x.toPrecision(12)) : (Number.isFinite(v.row.values[c.key]) ? v.row.values[c.key] : 0);
    }
    const offIds = new Set(v.row.off || []);
    return { id: v.id, name: v.name, values, off: part.features.filter((f) => offIds.has(f.id)).map((f) => f.name) };
  });
  return { columns, rows };
}

const num = (v) => String(Number(Number(v).toPrecision(12)));

const sizeOf = (mesh) => {
  const P = mesh.positions, min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
  for (let i = 0; i < P.length; i += 3) for (let k = 0; k < 3; k++) { min[k] = Math.min(min[k], P[i + k]); max[k] = Math.max(max[k], P[i + k]); }
  return [max[0] - min[0], max[2] - min[2], max[1] - min[1]].map((x) => Number(x.toFixed(4)));   // width (x), depth (z), height (y) of the Y-up model
};

stats[v.id] = { volume_mm3: regen.stats ? Number(Number(regen.stats.volume).toPrecision(9)) : null, size_mm: sizeOf(regen.mesh) };

/** The variant's mesh in library coordinates (Z up, front −Y, anchored back-middle-bottom) and its bounds. */
export function libraryBody(mesh, decimals) {
  const P = mesh.positions, n = P.length / 3;
  const q = new Array(P.length);
  let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, minZ = Infinity, maxZ = -Infinity;
  for (let i = 0; i < n; i++) {
    const x = P[i * 3], y = -P[i * 3 + 2], z = P[i * 3 + 1];   // (x, y, z) → (x, −z, y): rotate +90° about X
    q[i * 3] = x; q[i * 3 + 1] = y; q[i * 3 + 2] = z;
    if (x < minX) minX = x; if (x > maxX) maxX = x; if (y < minY) minY = y; if (y > maxY) maxY = y; if (z < minZ) minZ = z; if (z > maxZ) maxZ = z;
  }
  const ox = -(minX + maxX) / 2, oy = -maxY, oz = -minZ;
  const positions = new Array(q.length);
  for (let i = 0; i < n; i++) { positions[i * 3] = r(q[i * 3] + ox, decimals); positions[i * 3 + 1] = r(q[i * 3 + 1] + oy, decimals); positions[i * 3 + 2] = r(q[i * 3 + 2] + oz, decimals); }
  const bounds = { x: r(minX + ox, 2), y: r(minY + oy, 2), z: 0, w: r(maxX - minX, 2), d: r(maxY - minY, 2), h: r(maxZ - minZ, 2) };
  return { positions, indices: Array.from(mesh.indices), bounds };
}

const r = (v, d) => { const k = 10 ** d; const x = Math.round(v * k) / k; return x === 0 ? 0 : x; };