@lucablockltd/ultimate-packaging 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -3755,6 +3755,64 @@ function generateBecf12109(attr) {
   crease.push(line6(xSide2Mid, yFoldBottomStart, xEnd, D + C - 2));
   return { cut, crease, viewBox: { width: totalWidth, height: totalHeight } };
 }
+function generateOuterContour6(attr) {
+  const { length: A, width: B, height: C, glueArea } = attr;
+  const D = calcD2(C, B);
+  const kulak = glueArea ?? calcKulak2(B);
+  const totalWidth = kulak + 2 * A + 2 * B - 2;
+  const totalHeight = D + C + B / 2 + DIP2;
+  return [
+    { x: 0, y: 0 },
+    { x: totalWidth, y: 0 },
+    { x: totalWidth, y: totalHeight },
+    { x: 0, y: totalHeight }
+  ];
+}
+function offsetContour6(points, distance) {
+  const n = points.length;
+  const result = [];
+  for (let i = 0; i < n; i++) {
+    const prev = points[(i - 1 + n) % n];
+    const curr = points[i];
+    const next = points[(i + 1) % n];
+    const e1x = curr.x - prev.x;
+    const e1y = curr.y - prev.y;
+    const e2x = next.x - curr.x;
+    const e2y = next.y - curr.y;
+    const len1 = Math.sqrt(e1x * e1x + e1y * e1y);
+    const len2 = Math.sqrt(e2x * e2x + e2y * e2y);
+    if (len1 === 0 || len2 === 0) {
+      result.push(curr);
+      continue;
+    }
+    const n1x = e1y / len1;
+    const n1y = -e1x / len1;
+    const n2x = e2y / len2;
+    const n2y = -e2x / len2;
+    const ax = n1x + n2x;
+    const ay = n1y + n2y;
+    const aLen = Math.sqrt(ax * ax + ay * ay);
+    if (aLen < 1e-3) {
+      result.push({ x: curr.x + n1x * distance, y: curr.y + n1y * distance });
+      continue;
+    }
+    const nx = ax / aLen;
+    const ny = ay / aLen;
+    const dot = n1x * nx + n1y * ny;
+    const d = distance / Math.max(dot, 0.1);
+    result.push({ x: curr.x + nx * d, y: curr.y + ny * d });
+  }
+  return result;
+}
+function contourToPath6(points) {
+  if (points.length === 0) return "";
+  let d = `M${points[0].x} ${points[0].y}`;
+  for (let i = 1; i < points.length; i++) {
+    d += ` L${points[i].x} ${points[i].y}`;
+  }
+  d += " Z";
+  return d;
+}
 function generateDimensions6(attr, unit) {
   const { length: A, width: B, height: C, glueArea } = attr;
   const D = calcD2(C, B);
@@ -5039,6 +5097,156 @@ function computeLayoutForPaper4(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
+// src/utils/autoLayout/calculate/bags-pillows/becf-12109/index.ts
+function prepareRotation5(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function pairGrid4(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB = findMinStepX(pA, pB, 0);
+  if (gapAB <= 0) return emptyResult();
+  const pairW = gapAB + pB.width;
+  const pairH = Math.max(pA.height, pB.height);
+  const pairStepX = gapAB + findMinStepX(pB, pA, 0);
+  const pairStepY = Math.max(
+    findMinStepY(pA, pA, 0),
+    findMinStepY(pA, pB, gapAB),
+    findMinStepY(pB, pA, -gapAB),
+    findMinStepY(pB, pB, 0)
+  );
+  if (pairStepX <= 0 || pairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const pairCols = Math.max(0, Math.floor((usableW - pairW) / pairStepX) + 1);
+  const pairRows = Math.max(0, Math.floor((usableH - pairH) / pairStepY) + 1);
+  if (pairCols === 0 || pairRows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < pairRows; r++) {
+    for (let c = 0; c < pairCols; c++) {
+      const baseX = bounds.left + c * pairStepX;
+      const baseY = bounds.top + r * pairStepY;
+      const oxA = baseX;
+      const oyA = baseY;
+      placements.push({ x: oxA + rdA.bbOffset.dx, y: oyA + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (oxA < minX) minX = oxA;
+      if (oyA < minY) minY = oyA;
+      if (oxA + pA.width > maxX) maxX = oxA + pA.width;
+      if (oyA + pA.height > maxY) maxY = oyA + pA.height;
+      const oxB = baseX + gapAB;
+      const oyB = baseY;
+      placements.push({ x: oxB + rdB.bbOffset.dx, y: oyB + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (oxB < minX) minX = oxB;
+      if (oyB < minY) minY = oyB;
+      if (oxB + pB.width > maxX) maxX = oxB + pB.width;
+      if (oyB + pB.height > maxY) maxY = oyB + pB.height;
+    }
+  }
+  const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
+  const gapRight = bounds.right - pairsRightEdge;
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  const extraRotations = [rdA, rdB];
+  for (const rdExtra of extraRotations) {
+    const pe = rdExtra.profile;
+    if (pe.width <= gapRight) {
+      for (let r = 0; r < pairRows; r++) {
+        const ox = pairsRightEdge;
+        const oy = bounds.top + r * pairStepY;
+        if (ox + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: ox + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (ox + pe.width > maxX) maxX = ox + pe.width;
+        }
+      }
+      break;
+    }
+  }
+  for (const rdExtra of extraRotations) {
+    const pe = rdExtra.profile;
+    if (pe.height <= gapBottom) {
+      for (let c = 0; c < pairCols; c++) {
+        const oxA = bounds.left + c * pairStepX;
+        const oy = pairsBottomEdge;
+        if (oxA + pe.width <= bounds.right && oy + pe.height <= bounds.bottom) {
+          placements.push({ x: oxA + rdExtra.bbOffset.dx, y: oy + rdExtra.bbOffset.dy, rotation: rdExtra.deg });
+          if (oy + pe.height > maxY) maxY = oy + pe.height;
+        }
+      }
+      break;
+    }
+  }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function computeLayoutForPaper5(contourPoints, dielineW, dielineH, _paperWidth, _paperHeight, bounds) {
+  const rots = [0, 90, 180, 270];
+  const rd = /* @__PURE__ */ new Map();
+  for (const deg of rots) {
+    rd.set(deg, prepareRotation5(contourPoints, dielineW, dielineH, deg));
+  }
+  const results = [];
+  for (const deg of rots) {
+    results.push(singleRotGrid(rd.get(deg), bounds));
+  }
+  const allPairs = [
+    [0, 180],
+    [90, 270],
+    [0, 90],
+    [0, 270],
+    [90, 180],
+    [180, 270]
+  ];
+  for (const [a, b] of allPairs) {
+    const rdA = rd.get(a), rdB = rd.get(b);
+    const stepA = findMinStepX(rdA.profile, rdA.profile, 0);
+    if (stepA <= 0) continue;
+    for (let off = 0; off < stepA; off += 1) {
+      results.push(dualRotGrid(rdA, rdB, off, bounds));
+      results.push(dualRotGrid(rdB, rdA, off, bounds));
+    }
+  }
+  for (const [a, b] of allPairs) {
+    results.push(pairGrid4(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid4(rd.get(b), rd.get(a), bounds));
+  }
+  const singleResults = [];
+  const multiResults = [];
+  for (const r of results) {
+    if (r.count === 0) continue;
+    const rotations = new Set(r.placements.map((p) => p.rotation));
+    if (rotations.size > 1) {
+      multiResults.push(r);
+    } else {
+      singleResults.push(r);
+    }
+  }
+  function pickBest(arr) {
+    let b = arr[0] ?? emptyResult();
+    let bArea = (b.maxX - b.minX) * (b.maxY - b.minY);
+    for (const r of arr) {
+      const area = (r.maxX - r.minX) * (r.maxY - r.minY);
+      if (r.count > b.count || r.count === b.count && area < bArea) {
+        b = r;
+        bArea = area;
+      }
+    }
+    return b;
+  }
+  const bestSingle = pickBest(singleResults);
+  const bestMulti = pickBest(multiResults);
+  const best = bestMulti.count >= bestSingle.count && bestMulti.count > 0 ? bestMulti : bestSingle;
+  centerLayout(best, bounds);
+  return {
+    rotation: best.placements[0]?.rotation ?? 0,
+    placements: best.placements,
+    producedPerSheet: best.count
+  };
+}
+
 // src/utils/autoLayout/calculate/index.ts
 function resolveModelFunctions(modelId, attrs) {
   switch (modelId) {
@@ -5074,6 +5282,14 @@ function resolveModelFunctions(modelId, attrs) {
         offsetContour: offsetContour5
       };
     }
+    case "BECF-12109": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour6(a),
+        dieline: generateBecf12109(a),
+        offsetContour: offsetContour6
+      };
+    }
     case "BECF-1010A":
     default: {
       const a = attrs;
@@ -5095,6 +5311,8 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper3;
     case "BECF-12101":
       return computeLayoutForPaper4;
+    case "BECF-12109":
+      return computeLayoutForPaper5;
     default:
       return computeLayoutForPaperDefault;
   }
@@ -5108,11 +5326,11 @@ function calculateAutoLayout(rawConfig) {
     colorbarHeight: rawConfig.colorbarHeight ?? 5,
     isShowColorbar: rawConfig.isShowColorbar ?? true
   };
-  const { contour, dieline, offsetContour: offsetContour6 } = resolveModelFunctions(
+  const { contour, dieline, offsetContour: offsetContour7 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour6(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour7(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -6052,6 +6270,17 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour5(a)
       };
     }
+    case "BECF-12109": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour6(typedAttrs);
+      return {
+        dieline: generateBecf12109(typedAttrs),
+        contourPath: contourToPath6(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour6(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecf12109(a),
+        generateContour: (a) => generateOuterContour6(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -6101,6 +6330,14 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-12109":
+        return /* @__PURE__ */ jsx(
+          DIE_LINE_BECF_12109,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-1010A":
       default:
         return /* @__PURE__ */ jsx(