@lucablockltd/ultimate-packaging 1.0.1 → 1.0.3

package/dist/index.js

@@ -2067,6 +2067,142 @@ function bottomDustFlaps3(xSide1, xFront, xSide2, xEnd, yBody2, dustFlap, dfCorn
     dustFlapPath3(xSide2, xEnd, yBody2, 1, dustFlap, dfCorner, dfInset, dfVertical, "none", "edge")
   ];
 }
+function generateOuterContour3(attr) {
+  const { length, width, height, glueArea, dustFlap, tuckFlap } = attr;
+  const glueTaper = glueArea * GLUE_TAPER_RATIO3;
+  const dfInset = Math.min(dustFlap / 6, width * 0.2);
+  const dfCorner = Math.min(dustFlap * 0.1, dfInset * 0.6);
+  const dfVertical = Math.min(dustFlap / 6, dustFlap - dfCorner);
+  const xRear = glueArea;
+  const xSide1 = glueArea + length;
+  const xFront = glueArea + length + width;
+  const xSide2 = glueArea + length + width + length;
+  const xEnd = glueArea + 2 * length + 2 * width;
+  const yTop = 0;
+  const yFold1 = tuckFlap;
+  const yBody1 = tuckFlap + width;
+  const yBody2 = tuckFlap + width + height;
+  const yFold2 = tuckFlap + width + height + width;
+  const yBot = tuckFlap + 2 * width + height + tuckFlap;
+  const arcSteps = 8;
+  const points = [];
+  points.push({ x: 0, y: yBody2 - glueTaper });
+  points.push({ x: 0, y: yBody1 + glueTaper });
+  points.push({ x: xRear, y: yBody1 });
+  points.push({ x: xSide1, y: yBody1 });
+  points.push({ x: xSide1 + MT3, y: yBody1 });
+  points.push({ x: xSide1 + MT3, y: yBody1 - dfVertical });
+  points.push({ x: xSide1 + MT3 + dfCorner, y: yBody1 - dfVertical - dfCorner });
+  points.push({ x: xSide1 + dfInset, y: yBody1 - dustFlap });
+  points.push({ x: xFront - dfInset, y: yBody1 - dustFlap });
+  points.push({ x: xFront - dfCorner, y: yBody1 - dfCorner });
+  points.push({ x: xFront, y: yBody1 });
+  points.push({ x: xFront, y: yFold1 });
+  points.push({ x: xFront + MT3, y: yFold1 });
+  for (let i = 0; i <= arcSteps; i++) {
+    const a = Math.PI + Math.PI / 2 * (i / arcSteps);
+    points.push({
+      x: xFront + MT3 + ARC_R3 + ARC_R3 * Math.cos(a),
+      y: yTop + ARC_R3 + ARC_R3 * Math.sin(a)
+    });
+  }
+  for (let i = 0; i <= arcSteps; i++) {
+    const a = -Math.PI / 2 + Math.PI / 2 * (i / arcSteps);
+    points.push({
+      x: xSide2 - MT3 - ARC_R3 + ARC_R3 * Math.cos(a),
+      y: yTop + ARC_R3 + ARC_R3 * Math.sin(a)
+    });
+  }
+  points.push({ x: xSide2 - MT3, y: yFold1 });
+  points.push({ x: xSide2, y: yFold1 });
+  points.push({ x: xSide2, y: yBody1 });
+  points.push({ x: xSide2 + dfCorner, y: yBody1 - dfCorner });
+  points.push({ x: xSide2 + dfInset, y: yBody1 - dustFlap });
+  points.push({ x: xEnd - dfInset, y: yBody1 - dustFlap });
+  points.push({ x: xEnd - dfCorner, y: yBody1 - dfVertical - dfCorner });
+  points.push({ x: xEnd, y: yBody1 - dfVertical });
+  points.push({ x: xEnd, y: yBody1 });
+  points.push({ x: xEnd, y: yBody2 });
+  points.push({ x: xEnd, y: yBody2 + dfVertical });
+  points.push({ x: xEnd - dfCorner, y: yBody2 + dfVertical + dfCorner });
+  points.push({ x: xEnd - dfInset, y: yBody2 + dustFlap });
+  points.push({ x: xSide2 + dfInset, y: yBody2 + dustFlap });
+  points.push({ x: xSide2 + dfCorner, y: yBody2 + dfCorner });
+  points.push({ x: xSide2, y: yBody2 });
+  points.push({ x: xSide2, y: yFold2 });
+  points.push({ x: xSide2 - MT3, y: yFold2 });
+  for (let i = 0; i <= arcSteps; i++) {
+    const a = Math.PI / 2 * (i / arcSteps);
+    points.push({
+      x: xSide2 - MT3 - ARC_R3 + ARC_R3 * Math.cos(a),
+      y: yBot - ARC_R3 + ARC_R3 * Math.sin(a)
+    });
+  }
+  for (let i = 0; i <= arcSteps; i++) {
+    const a = Math.PI / 2 + Math.PI / 2 * (i / arcSteps);
+    points.push({
+      x: xFront + MT3 + ARC_R3 + ARC_R3 * Math.cos(a),
+      y: yBot - ARC_R3 + ARC_R3 * Math.sin(a)
+    });
+  }
+  points.push({ x: xFront + MT3, y: yFold2 });
+  points.push({ x: xFront, y: yFold2 });
+  points.push({ x: xFront, y: yBody2 });
+  points.push({ x: xFront - dfCorner, y: yBody2 + dfCorner });
+  points.push({ x: xFront - dfInset, y: yBody2 + dustFlap });
+  points.push({ x: xSide1 + dfInset, y: yBody2 + dustFlap });
+  points.push({ x: xSide1 + MT3 + dfCorner, y: yBody2 + dfVertical + dfCorner });
+  points.push({ x: xSide1 + MT3, y: yBody2 + dfVertical });
+  points.push({ x: xSide1 + MT3, y: yBody2 });
+  points.push({ x: xSide1, y: yBody2 });
+  points.push({ x: xRear, y: yBody2 });
+  return points;
+}
+function offsetContour3(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 contourToPath3(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 generateDimensions3(attr, unit) {
   const { length, width, height, glueArea, dustFlap, tuckFlap } = attr;
   const factor = unit === "cm" ? 0.1 : unit === "in" ? 1 / 25.4 : 1;
@@ -2553,7 +2689,7 @@ function bottomFlaps(xRear, xSide1, xFront, xSide2, xEnd, yBody2, yBot) {
   );
   return paths;
 }
-function generateOuterContour3(attr) {
+function generateOuterContour4(attr) {
   const { length, width, height, flapHeight, glueArea } = attr;
   const glueTaper = glueArea * GLUE_TAPER_RATIO4;
   const xRear = glueArea;
@@ -2604,7 +2740,7 @@ function generateOuterContour3(attr) {
   points.push({ x: xRear, y: yBody2 });
   return points;
 }
-function offsetContour3(points, distance) {
+function offsetContour4(points, distance) {
   const n = points.length;
   const result = [];
   for (let i = 0; i < n; i++) {
@@ -2640,7 +2776,7 @@ function offsetContour3(points, distance) {
   }
   return result;
 }
-function contourToPath3(points) {
+function contourToPath4(points) {
   if (points.length === 0) return "";
   let d = `M${points[0].x} ${points[0].y}`;
   for (let i = 1; i < points.length; i++) {
@@ -3537,9 +3673,238 @@ function computeLayoutForPaper2(contourPoints, dielineW, dielineH, _paperWidth,
   };
 }
 
+// src/utils/autoLayout/calculate/tuck-end-boxes/becf-1040a/index.ts
+function prepareRotation3(contourPoints, dielineW, dielineH, deg) {
+  const rotated = normalizePoints(contourPoints, deg);
+  return {
+    profile: buildProfile(rotated),
+    bbOffset: computeDielineBBOffset(contourPoints, dielineW, dielineH, deg),
+    deg
+  };
+}
+function findPairRowStepY(pA, pB, gapAB, pairStepX) {
+  const reach = Math.max(pA.width, pB.width) + Math.abs(gapAB);
+  const nMin = Math.floor(-reach / pairStepX) - 1;
+  const nMax = Math.ceil(reach / pairStepX) + 1;
+  let maxStep = 0;
+  for (let n = nMin; n <= nMax; n++) {
+    const dx = n * pairStepX;
+    const s1 = findMinStepY(pA, pA, dx);
+    if (s1 > maxStep) maxStep = s1;
+    const s2 = findMinStepY(pA, pB, dx + gapAB);
+    if (s2 > maxStep) maxStep = s2;
+    const s3 = findMinStepY(pB, pA, dx - gapAB);
+    if (s3 > maxStep) maxStep = s3;
+    const s4 = findMinStepY(pB, pB, dx);
+    if (s4 > maxStep) maxStep = s4;
+  }
+  return maxStep;
+}
+function pairGrid2(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);
+  if (pairStepX <= 0) return emptyResult();
+  const pairStepY = findPairRowStepY(pA, pB, gapAB, pairStepX);
+  if (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;
+      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (baseX < minX) minX = baseX;
+      if (baseY < minY) minY = baseY;
+      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
+      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
+      const bx = baseX + gapAB;
+      placements.push({ x: bx + rdB.bbOffset.dx, y: baseY + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (bx < minX) minX = bx;
+      if (bx + pB.width > maxX) maxX = bx + pB.width;
+      if (baseY + pB.height > maxY) maxY = baseY + pB.height;
+    }
+  }
+  const pairsRightEdge = bounds.left + (pairCols - 1) * pairStepX + pairW;
+  const gapRight = bounds.right - pairsRightEdge;
+  for (const rdExtra of [rdA, rdB]) {
+    const pe = rdExtra.profile;
+    if (pe.width > gapRight) continue;
+    const dxFromB = pairsRightEdge - (bounds.left + (pairCols - 1) * pairStepX + gapAB);
+    const dxFromA = pairsRightEdge - bounds.left - (pairCols - 1) * pairStepX;
+    const extraStepY = Math.max(
+      findMinStepY(pA, pe, dxFromA),
+      findMinStepY(pB, pe, dxFromB),
+      findMinStepY(pe, pe, 0)
+    );
+    if (extraStepY <= 0) continue;
+    const effectiveStepY = Math.max(pairStepY, extraStepY);
+    const extraRows = Math.max(0, Math.floor((usableH - pe.height) / effectiveStepY) + 1);
+    for (let r = 0; r < extraRows; r++) {
+      const ox = pairsRightEdge;
+      const oy = bounds.top + r * effectiveStepY;
+      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;
+        if (oy + pe.height > maxY) maxY = oy + pe.height;
+      }
+    }
+    break;
+  }
+  const pairsBottomEdge = bounds.top + (pairRows - 1) * pairStepY + pairH;
+  const gapBottom = bounds.bottom - pairsBottomEdge;
+  for (const rdExtra of [rdA, rdB]) {
+    const pe = rdExtra.profile;
+    if (pe.height > gapBottom) continue;
+    const extraStepX = findMinStepX(pe, pe, 0);
+    if (extraStepX <= 0) continue;
+    const dyFromPairRow = pairsBottomEdge - (bounds.top + (pairRows - 1) * pairStepY);
+    const stepFromA = findMinStepY(pA, pe, 0);
+    const stepFromB = findMinStepY(pB, pe, gapAB);
+    if (dyFromPairRow < stepFromA || dyFromPairRow < stepFromB) continue;
+    const extraCols = Math.max(0, Math.floor((usableW - pe.width) / extraStepX) + 1);
+    for (let c = 0; c < extraCols; c++) {
+      const ox = bounds.left + c * extraStepX;
+      const oy = pairsBottomEdge;
+      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;
+        if (oy + pe.height > maxY) maxY = oy + pe.height;
+      }
+    }
+    break;
+  }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function verticalPairGrid(rdA, rdB, bounds) {
+  const pA = rdA.profile, pB = rdB.profile;
+  const gapAB_Y = findMinStepY(pA, pB, 0);
+  if (gapAB_Y <= 0) return emptyResult();
+  const vpairH = gapAB_Y + pB.height;
+  const vpairW = Math.max(pA.width, pB.width);
+  Math.max(pA.height, pB.height) + Math.abs(gapAB_Y);
+  let vpairStepX = 0;
+  {
+    const stepXAA = findMinStepX(pA, pA, 0);
+    const stepXAB = findMinStepX(pA, pB, -gapAB_Y);
+    const stepXBA = findMinStepX(pB, pA, gapAB_Y);
+    const stepXBB = findMinStepX(pB, pB, 0);
+    vpairStepX = Math.max(stepXAA, stepXAB, stepXBA, stepXBB);
+  }
+  if (vpairStepX <= 0) return emptyResult();
+  const vpairStepY = gapAB_Y + findMinStepY(pB, pA, 0);
+  if (vpairStepY <= 0) return emptyResult();
+  const usableW = bounds.right - bounds.left;
+  const usableH = bounds.bottom - bounds.top;
+  const cols = Math.max(0, Math.floor((usableW - vpairW) / vpairStepX) + 1);
+  const rows = Math.max(0, Math.floor((usableH - vpairH) / vpairStepY) + 1);
+  if (cols === 0 || rows === 0) return emptyResult();
+  const placements = [];
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      const baseX = bounds.left + c * vpairStepX;
+      const baseY = bounds.top + r * vpairStepY;
+      placements.push({ x: baseX + rdA.bbOffset.dx, y: baseY + rdA.bbOffset.dy, rotation: rdA.deg });
+      if (baseX < minX) minX = baseX;
+      if (baseY < minY) minY = baseY;
+      if (baseX + pA.width > maxX) maxX = baseX + pA.width;
+      if (baseY + pA.height > maxY) maxY = baseY + pA.height;
+      const by = baseY + gapAB_Y;
+      placements.push({ x: baseX + rdB.bbOffset.dx, y: by + rdB.bbOffset.dy, rotation: rdB.deg });
+      if (by + pB.height > maxY) maxY = by + pB.height;
+    }
+  }
+  return { placements, count: placements.length, minX, minY, maxX, maxY };
+}
+function computeLayoutForPaper3(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, prepareRotation3(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(pairGrid2(rd.get(a), rd.get(b), bounds));
+    results.push(pairGrid2(rd.get(b), rd.get(a), bounds));
+  }
+  for (const [a, b] of allPairs) {
+    results.push(verticalPairGrid(rd.get(a), rd.get(b), bounds));
+    results.push(verticalPairGrid(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) {
+    case "BECF-1040A": {
+      const a = attrs;
+      return {
+        contour: generateOuterContour3(a),
+        dieline: generateBecf1040a(a),
+        offsetContour: offsetContour3
+      };
+    }
     case "BECF-1030A": {
       const a = attrs;
       return {
@@ -3551,9 +3916,9 @@ function resolveModelFunctions(modelId, attrs) {
     case "BECF-11D01": {
       const a = attrs;
       return {
-        contour: generateOuterContour3(a),
+        contour: generateOuterContour4(a),
         dieline: generateBecf11d01(a),
-        offsetContour: offsetContour3
+        offsetContour: offsetContour4
       };
     }
     case "BECF-1010A":
@@ -3573,16 +3938,18 @@ function resolveLayoutCalculator(modelId) {
       return computeLayoutForPaper;
     case "BECF-1030A":
       return computeLayoutForPaper2;
+    case "BECF-1040A":
+      return computeLayoutForPaper3;
     default:
       return computeLayoutForPaperDefault;
   }
 }
 function calculateAutoLayout(config) {
-  const { contour, dieline, offsetContour: offsetContour4 } = resolveModelFunctions(
+  const { contour, dieline, offsetContour: offsetContour5 } = resolveModelFunctions(
     config.model.modelId,
     config.model.attributes
   );
-  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour4(contour, config.layoutDistance / 2) : contour;
+  const offsetContourPoints = config.layoutDistance > 0 ? offsetContour5(contour, config.layoutDistance / 2) : contour;
   const cbDepth = config.isShowColorbar ? config.colorbarHeight : 0;
   const computeLayout = resolveLayoutCalculator(config.model.modelId);
   const paperResults = [];
@@ -3919,6 +4286,14 @@ function renderDieLine(modelId, attrs) {
           renderAs: "group"
         }
       );
+    case "BECF-1040A":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        DIE_LINE_BECF_1040A,
+        {
+          attributes: attrs,
+          renderAs: "group"
+        }
+      );
     case "BECF-1010A":
     default:
       return /* @__PURE__ */ jsxRuntime.jsx(
@@ -4462,17 +4837,28 @@ function resolveModel(modelId, attrs, layoutDistance) {
         generateContour: (a) => generateOuterContour2(a)
       };
     }
-    case "BECF-11D01": {
+    case "BECF-1040A": {
       const typedAttrs = attrs;
       const contour = generateOuterContour3(typedAttrs);
       return {
-        dieline: generateBecf11d01(typedAttrs),
+        dieline: generateBecf1040a(typedAttrs),
         contourPath: contourToPath3(contour),
         offsetContourPoints: layoutDistance > 0 ? offsetContour3(contour, layoutDistance / 2) : contour,
-        generate: (a) => generateBecf11d01(a),
+        generate: (a) => generateBecf1040a(a),
         generateContour: (a) => generateOuterContour3(a)
       };
     }
+    case "BECF-11D01": {
+      const typedAttrs = attrs;
+      const contour = generateOuterContour4(typedAttrs);
+      return {
+        dieline: generateBecf11d01(typedAttrs),
+        contourPath: contourToPath4(contour),
+        offsetContourPoints: layoutDistance > 0 ? offsetContour4(contour, layoutDistance / 2) : contour,
+        generate: (a) => generateBecf11d01(a),
+        generateContour: (a) => generateOuterContour4(a)
+      };
+    }
     case "BECF-1010A":
     default: {
       const typedAttrs = attrs;
@@ -4498,6 +4884,14 @@ function renderDieLine2(modelId, attrs) {
             renderAs: "group"
           }
         );
+      case "BECF-1040A":
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          DIE_LINE_BECF_1040A,
+          {
+            attributes: attrs,
+            renderAs: "group"
+          }
+        );
       case "BECF-11D01":
         return /* @__PURE__ */ jsxRuntime.jsx(
           DIE_LINE_BECF_11D01,