circuit-json-to-tscircuit 0.0.92 → 0.0.93

package/dist/{chunk-GAMHGAGS.js → chunk-B7377FUZ.js}

@@ -504,9 +504,9 @@ function getCadModelPlacementAttributes({
   if (cadComponent.size !== void 0) {
     attributes.push(`size={${formatPointProp(cadComponent.size)}}`);
   }
-  if (cadComponent.show_as_translucent_model === true) {
-    attributes.push("showAsTranslucentModel");
-  }
+  attributes.push(
+    `showAsTranslucentModel={${cadComponent.show_as_translucent_model === true}}`
+  );
   return attributes;
 }
 
@@ -539,48 +539,397 @@ function generateCadModelTsx({
   return `<cadmodel ${attributes.join(" ")} />`;
 }
 
-// lib/generate-board-cad-models-tsx/generate-jscad-cad-model-tsx.ts
-function generateJscadCadModelTsx({
+// lib/generate-board-cad-models-tsx/get-jscad-operation-fit-scale-factors.ts
+import jscad2 from "@jscad/modeling";
+
+// lib/generate-board-cad-models-tsx/execute-jscad-operation.ts
+import jscad from "@jscad/modeling";
+import { executeJscadOperations } from "jscad-planner";
+function executeJscadOperation(operation) {
+  return executeJscadOperations(jscad, operation);
+}
+
+// lib/generate-board-cad-models-tsx/get-jscad-operation-fit-scale-factors.ts
+var identityScaleFactors = { x: 1, y: 1, z: 1 };
+function getSafeScaleFactor({
+  sourceLength,
+  targetLength
+}) {
+  return sourceLength > 0 ? targetLength / sourceLength : 1;
+}
+function getJscadOperationFitScaleFactors({
+  cadComponent,
+  operation
+}) {
+  if (cadComponent.size === void 0) return identityScaleFactors;
+  const geometry = executeJscadOperation(operation);
+  if (!jscad2.geometries.geom3.isA(geometry)) return identityScaleFactors;
+  const [minimumPoint, maximumPoint] = jscad2.measurements.measureBoundingBox(geometry);
+  const modelUnitToMmScaleFactor = cadComponent.model_unit_to_mm_scale_factor ?? 1;
+  const axisScaleFactors = {
+    x: getSafeScaleFactor({
+      sourceLength: maximumPoint[0] - minimumPoint[0],
+      targetLength: cadComponent.size.x * modelUnitToMmScaleFactor
+    }),
+    y: getSafeScaleFactor({
+      sourceLength: maximumPoint[1] - minimumPoint[1],
+      targetLength: cadComponent.size.y * modelUnitToMmScaleFactor
+    }),
+    z: getSafeScaleFactor({
+      sourceLength: maximumPoint[2] - minimumPoint[2],
+      targetLength: cadComponent.size.z * modelUnitToMmScaleFactor
+    })
+  };
+  if (cadComponent.model_object_fit === "fill_bounds") {
+    return axisScaleFactors;
+  }
+  const uniformScaleFactor = Math.min(
+    axisScaleFactors.x,
+    axisScaleFactors.y,
+    axisScaleFactors.z
+  );
+  return {
+    x: uniformScaleFactor,
+    y: uniformScaleFactor,
+    z: uniformScaleFactor
+  };
+}
+
+// lib/generate-board-cad-models-tsx/get-jscad-operation-in-base-model-frame.ts
+var degreesToRadians = (angleDegrees) => angleDegrees * Math.PI / 180;
+var getCadComponentRotation = (cadComponent) => cadComponent.rotation ?? { x: 0, y: 0, z: 0 };
+var getModelOriginPosition = (cadComponent) => cadComponent.model_origin_position ?? { x: 0, y: 0, z: 0 };
+var getBoardNormalRotation = (cadComponent) => {
+  switch (cadComponent.model_board_normal_direction ?? "z+") {
+    case "x+":
+      return { x: 0, y: -90, z: 0 };
+    case "x-":
+      return { x: 0, y: 90, z: 0 };
+    case "y+":
+      return { x: 90, y: 0, z: 0 };
+    case "y-":
+      return { x: -90, y: 0, z: 0 };
+    case "z-":
+      return { x: 180, y: 0, z: 0 };
+    case "z+":
+      return { x: 0, y: 0, z: 0 };
+  }
+};
+var rotateOperation = ({
+  operation,
+  rotationDegrees
+}) => {
+  let rotatedOperation = operation;
+  for (const [axis, angleDegrees] of [
+    ["Z", rotationDegrees.z],
+    ["Y", rotationDegrees.y],
+    ["X", rotationDegrees.x]
+  ]) {
+    if (angleDegrees === 0) continue;
+    rotatedOperation = {
+      type: `rotate${axis}`,
+      angle: degreesToRadians(angleDegrees),
+      shape: rotatedOperation
+    };
+  }
+  return rotatedOperation;
+};
+var rotateOperationByInverse = ({
+  operation,
+  rotationDegrees
+}) => {
+  let rotatedOperation = operation;
+  for (const [axis, angleDegrees] of [
+    ["X", rotationDegrees.x],
+    ["Y", rotationDegrees.y],
+    ["Z", rotationDegrees.z]
+  ]) {
+    if (angleDegrees === 0) continue;
+    rotatedOperation = {
+      type: `rotate${axis}`,
+      angle: degreesToRadians(-angleDegrees),
+      shape: rotatedOperation
+    };
+  }
+  return rotatedOperation;
+};
+var translateOperation = ({
+  operation,
+  translation
+}) => {
+  if (translation.x === 0 && translation.y === 0 && translation.z === 0) {
+    return operation;
+  }
+  return {
+    type: "translate",
+    vector: [translation.x, translation.y, translation.z],
+    shape: operation
+  };
+};
+var scaleOperation = ({
+  operation,
+  scaleFactors
+}) => {
+  if (scaleFactors.x === 1 && scaleFactors.y === 1 && scaleFactors.z === 1) {
+    return operation;
+  }
+  return {
+    type: "scale",
+    factors: [scaleFactors.x, scaleFactors.y, scaleFactors.z],
+    shape: operation
+  };
+};
+function getJscadOperationInBaseModelFrame({
+  baseCadComponent,
+  basePositionOffset,
+  cadComponent,
+  positionOffset
+}) {
+  if (cadComponent.model_jscad === void 0) return void 0;
+  const modelOriginPosition = getModelOriginPosition(cadComponent);
+  const cadRotationDegrees = getCadComponentRotation(cadComponent);
+  const baseCadRotationDegrees = getCadComponentRotation(baseCadComponent);
+  const modelUnitToMmScaleFactor = cadComponent.model_unit_to_mm_scale_factor ?? 1;
+  let operation = cadComponent.model_jscad;
+  operation = scaleOperation({
+    operation,
+    scaleFactors: {
+      x: modelUnitToMmScaleFactor,
+      y: modelUnitToMmScaleFactor,
+      z: modelUnitToMmScaleFactor
+    }
+  });
+  operation = translateOperation({
+    operation,
+    translation: {
+      x: -modelOriginPosition.x,
+      y: -modelOriginPosition.y,
+      z: -modelOriginPosition.z
+    }
+  });
+  operation = rotateOperation({
+    operation,
+    rotationDegrees: getBoardNormalRotation(cadComponent)
+  });
+  operation = scaleOperation({
+    operation,
+    scaleFactors: getJscadOperationFitScaleFactors({
+      cadComponent,
+      operation
+    })
+  });
+  operation = rotateOperation({
+    operation,
+    rotationDegrees: cadRotationDegrees
+  });
+  operation = translateOperation({
+    operation,
+    translation: {
+      x: positionOffset.x - basePositionOffset.x,
+      y: positionOffset.y - basePositionOffset.y,
+      z: positionOffset.z - basePositionOffset.z
+    }
+  });
+  return rotateOperationByInverse({
+    operation,
+    rotationDegrees: baseCadRotationDegrees
+  });
+}
+
+// lib/generate-board-cad-models-tsx/pack-jscad-operations.ts
+import jscad3 from "@jscad/modeling";
+import "jscad-planner";
+var copyPolygon = ({
+  polygon,
+  geometryColor
+}) => ({
+  vertices: polygon.vertices.map(([x, y, z]) => [x, y, z]),
+  color: polygon.color ?? geometryColor
+});
+var getPackedJscadSize = (polygons) => {
+  const vertices = polygons.flatMap((polygon) => polygon.vertices);
+  if (vertices.length === 0) return void 0;
+  const [firstVertex, ...remainingVertices] = vertices;
+  let minX = firstVertex[0];
+  let minY = firstVertex[1];
+  let minZ = firstVertex[2];
+  let maxX = firstVertex[0];
+  let maxY = firstVertex[1];
+  let maxZ = firstVertex[2];
+  for (const [x, y, z] of remainingVertices) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    minZ = Math.min(minZ, z);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+    maxZ = Math.max(maxZ, z);
+  }
+  return { x: maxX - minX, y: maxY - minY, z: maxZ - minZ };
+};
+var packJscadOperations = (operations) => {
+  const polygons = [];
+  for (const operation of operations) {
+    const geometry = executeJscadOperation(operation);
+    if (!jscad3.geometries.geom3.isA(geometry)) return void 0;
+    polygons.push(
+      ...jscad3.geometries.geom3.toPolygons(geometry).map(
+        (polygon) => copyPolygon({
+          polygon,
+          geometryColor: geometry.color
+        })
+      )
+    );
+  }
+  return {
+    jscad: { type: "createGeom3", polygons },
+    size: getPackedJscadSize(polygons)
+  };
+};
+
+// lib/generate-board-cad-models-tsx/generate-jscad-cad-model-prop-tsx.ts
+function generateSingleJscadCadModelPropTsx({
   cadComponent,
   parentPlacement,
   pcbBoard
 }) {
-  if (cadComponent.model_jscad === void 0) return void 0;
-  const attributes = [
-    `jscad={${JSON.stringify(cadComponent.model_jscad)}}`,
-    ...getCadModelPlacementAttributes({
+  const placement = getCadModelPlacement({
+    cadComponent,
+    parentPlacement,
+    pcbBoard
+  });
+  const properties = [
+    `jscad: ${JSON.stringify(cadComponent.model_jscad)}`,
+    `positionOffset: ${formatPointProp(placement.positionOffset)}`,
+    `rotationOffset: ${formatPointProp(placement.ccwRotationOffsetDegrees)}`
+  ];
+  const modelOriginPosition = getCadModelOriginPosition(cadComponent);
+  if (modelOriginPosition !== void 0) {
+    properties.push(
+      `modelOriginPosition: ${formatPointProp(modelOriginPosition)}`
+    );
+  }
+  if (cadComponent.model_unit_to_mm_scale_factor !== void 0) {
+    properties.push(
+      `modelUnitToMmScale: ${cadComponent.model_unit_to_mm_scale_factor}`
+    );
+  }
+  if (cadComponent.model_board_normal_direction !== void 0) {
+    properties.push(
+      `modelBoardNormalDirection: ${JSON.stringify(cadComponent.model_board_normal_direction)}`
+    );
+  }
+  if (cadComponent.size !== void 0) {
+    properties.push(`size: ${formatPointProp(cadComponent.size)}`);
+  }
+  return `{ ${properties.join(", ")} }`;
+}
+function generateJscadCadModelPropTsx({
+  cadComponents,
+  parentPlacement,
+  pcbBoard
+}) {
+  const baseCadComponent = cadComponents[0];
+  if (!baseCadComponent || baseCadComponent.model_jscad === void 0) {
+    return void 0;
+  }
+  if (cadComponents.length === 1) {
+    return generateSingleJscadCadModelPropTsx({
+      cadComponent: baseCadComponent,
+      parentPlacement,
+      pcbBoard
+    });
+  }
+  const basePlacement = getCadModelPlacement({
+    cadComponent: baseCadComponent,
+    parentPlacement,
+    pcbBoard
+  });
+  const shapes = cadComponents.flatMap((cadComponent) => {
+    const placement = getCadModelPlacement({
       cadComponent,
       parentPlacement,
       pcbBoard
-    })
+    });
+    const operation = getJscadOperationInBaseModelFrame({
+      baseCadComponent,
+      basePositionOffset: basePlacement.positionOffset,
+      cadComponent,
+      positionOffset: placement.positionOffset
+    });
+    return operation ? [operation] : [];
+  });
+  if (shapes.length === 0) return void 0;
+  const packedJscadOperations = packJscadOperations(shapes);
+  const jscad4 = packedJscadOperations?.jscad ?? {
+    type: "union",
+    shapes
+  };
+  const properties = [
+    `jscad: ${JSON.stringify(jscad4)}`,
+    `positionOffset: ${formatPointProp(basePlacement.positionOffset)}`,
+    `rotationOffset: ${formatPointProp(basePlacement.ccwRotationOffsetDegrees)}`,
+    `modelOriginPosition: ${formatPointProp({ x: 0, y: 0, z: 0 })}`,
+    "modelUnitToMmScale: 1",
+    'modelBoardNormalDirection: "z+"'
   ];
-  return `<cadmodel ${attributes.join(" ")} />`;
+  if (packedJscadOperations?.size !== void 0) {
+    properties.push(`size: ${formatPointProp(packedJscadOperations.size)}`);
+  }
+  return `{ ${properties.join(", ")} }`;
 }
 
 // lib/generate-board-cad-models-tsx/generate-cad-model-group-model-tsx.ts
-var generateCadModelElementsTsx = ({
+var generateUrlCadModelElementsTsx = ({
   cadModelGroup,
   pcbBoard
 }) => cadModelGroup.cadComponents.flatMap((cadComponent) => {
-  const modelElementGenerator = cadComponent.model_jscad === void 0 ? generateCadModelTsx : generateJscadCadModelTsx;
-  const modelElement = modelElementGenerator({
+  if (getCadModelUrl(cadComponent) === void 0) return [];
+  const modelElement = generateCadModelTsx({
     cadComponent,
     parentPlacement: cadModelGroup.parentPlacement,
     pcbBoard
   });
   return modelElement ? [modelElement] : [];
 });
+var getJscadCadComponents = (cadModelGroup) => cadModelGroup.cadComponents.filter(
+  (cadComponent) => cadComponent.model_jscad !== void 0
+);
 function generateCadModelGroupModelTsx({
   cadModelGroup,
   pcbBoard
 }) {
-  const modelElements = generateCadModelElementsTsx({
+  const jscadCadComponents = getJscadCadComponents(cadModelGroup);
+  if (jscadCadComponents.length > 0) {
+    return generateJscadCadModelPropTsx({
+      cadComponents: jscadCadComponents,
+      parentPlacement: cadModelGroup.parentPlacement,
+      pcbBoard
+    });
+  }
+  const urlCadModelElementsTsx = generateUrlCadModelElementsTsx({
     cadModelGroup,
     pcbBoard
   });
-  if (modelElements.length === 0) return void 0;
-  if (modelElements.length === 1) return modelElements[0];
-  return `<cadassembly>${modelElements.join("\n")}</cadassembly>`;
+  if (urlCadModelElementsTsx.length === 0) return void 0;
+  if (urlCadModelElementsTsx.length === 1) return urlCadModelElementsTsx[0];
+  return `<cadassembly>${urlCadModelElementsTsx.join("\n")}</cadassembly>`;
+}
+function generateCadModelGroupChildrenTsx({
+  cadModelGroup,
+  pcbBoard
+}) {
+  if (getJscadCadComponents(cadModelGroup).length === 0) return [];
+  return generateUrlCadModelElementsTsx({ cadModelGroup, pcbBoard });
+}
+
+// lib/generate-board-cad-models-tsx/is-jscad-cad-model-group-translucent.ts
+function isJscadCadModelGroupTranslucent(cadModelGroup) {
+  const jscadCadComponents = cadModelGroup.cadComponents.filter(
+    (cadComponent) => cadComponent.model_jscad !== void 0
+  );
+  return jscadCadComponents.length > 0 && jscadCadComponents.every(
+    (cadComponent) => cadComponent.show_as_translucent_model === true
+  );
 }
 
 // lib/generate-board-cad-models-tsx/generate-cad-model-group-tsx.ts
@@ -606,7 +955,17 @@ function generateCadModelGroupTsx({
     "footprint={<footprint />}",
     `cadModel={${cadModelTsx}}`
   ];
-  return `<chip ${attributes.join(" ")} />`;
+  if (isJscadCadModelGroupTranslucent(cadModelGroup)) {
+    attributes.push("showAsTranslucentModel");
+  }
+  const childModelElementsTsx = generateCadModelGroupChildrenTsx({
+    cadModelGroup,
+    pcbBoard
+  });
+  if (childModelElementsTsx.length === 0) {
+    return `<chip ${attributes.join(" ")} />`;
+  }
+  return `<chip ${attributes.join(" ")}>${childModelElementsTsx.join("\n")}</chip>`;
 }
 
 // lib/board-converter/stages/convert-board-cad-models.ts
@@ -3513,6 +3872,10 @@ var convertPcbComponents = ({
       cadModelGroup: localizedCadModelGroup,
       pcbBoard
     }) : void 0;
+    const childModelElementsTsx = localizedCadModelGroup ? generateCadModelGroupChildrenTsx({
+      cadModelGroup: localizedCadModelGroup,
+      pcbBoard
+    }) : [];
     const componentProps = [
       `name=${formatJsxStringAttribute(componentName)}`,
       `pcbX={${componentPosition.x}}`,
@@ -3524,6 +3887,9 @@ var convertPcbComponents = ({
     if (cadModelTsx) {
       componentProps.push(`cadModel={${cadModelTsx}}`);
     }
+    if (localizedCadModelGroup && isJscadCadModelGroupTranslucent(localizedCadModelGroup)) {
+      componentProps.push("showAsTranslucentModel");
+    }
     if (pinLabels) {
       componentProps.push(`pinLabels={${JSON.stringify(pinLabels)}}`);
     }
@@ -3543,8 +3909,9 @@ var convertPcbComponents = ({
     if (pcbComponent.obstructs_within_bounds === false) {
       componentProps.push("obstructsWithinBounds={false}");
     }
+    const chipOpeningTsx = `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}}`;
     boardChildren.push(
-      `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}} />`
+      childModelElementsTsx.length === 0 ? `${chipOpeningTsx} />` : `${chipOpeningTsx}>${childModelElementsTsx.join("\n")}</chip>`
     );
   }
 };

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-GAMHGAGS.js";
+} from "../chunk-B7377FUZ.js";
 
 // cli/main.ts
 import { Command } from "commander";
@@ -16,7 +16,7 @@ var package_default = {
     "./cli": "./dist/cli/main.js"
   },
   type: "module",
-  version: "0.0.91",
+  version: "0.0.92",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-tscircuit.git"
@@ -58,10 +58,6 @@ var package_default = {
   },
   peerDependencies: {
     typescript: "^5.0.0"
-  },
-  overrides: {
-    "@tscircuit/core": "https://pkg.pr.new/tscircuit/core/@tscircuit/core@3013d38",
-    "@tscircuit/props": "https://pkg.pr.new/@tscircuit/props@074b67d"
   }
 };
 

package/dist/lib/index.js

@@ -1,6 +1,6 @@
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-GAMHGAGS.js";
+} from "../chunk-B7377FUZ.js";
 export {
   convertCircuitJsonToTscircuit
 };

package/lib/board-converter/stages/convert-pcb-components.ts

@@ -2,8 +2,12 @@ import type { AnyCircuitElement, PcbComponent } from "circuit-json"
 import type { BoardConversionContext as FootprintConversionContext } from "../../board-conversion-context"
 import { formatJsxStringAttribute } from "../../format-jsx-string-attribute"
 import type { CadModelGroup } from "../../generate-board-cad-models-tsx/converter-types"
-import { generateCadModelGroupModelTsx } from "../../generate-board-cad-models-tsx/generate-cad-model-group-model-tsx"
+import {
+  generateCadModelGroupChildrenTsx,
+  generateCadModelGroupModelTsx,
+} from "../../generate-board-cad-models-tsx/generate-cad-model-group-model-tsx"
 import { getCadModelGroups } from "../../generate-board-cad-models-tsx/get-cad-model-groups"
+import { isJscadCadModelGroupTranslucent } from "../../generate-board-cad-models-tsx/is-jscad-cad-model-group-translucent"
 import { generateFootprintTsx } from "../../generate-footprint-tsx"
 import type { BoardConverterStage } from "../BoardConverterContext"
 import { getPcbComponentRenderPlacement } from "../get-pcb-component-render-placement"
@@ -130,6 +134,12 @@ export const convertPcbComponents: BoardConverterStage = ({
           pcbBoard,
         })
       : undefined
+    const childModelElementsTsx = localizedCadModelGroup
+      ? generateCadModelGroupChildrenTsx({
+          cadModelGroup: localizedCadModelGroup,
+          pcbBoard,
+        })
+      : []
     const componentProps = [
       `name=${formatJsxStringAttribute(componentName)}`,
       `pcbX={${componentPosition.x}}`,
@@ -142,6 +152,12 @@ export const convertPcbComponents: BoardConverterStage = ({
     if (cadModelTsx) {
       componentProps.push(`cadModel={${cadModelTsx}}`)
     }
+    if (
+      localizedCadModelGroup &&
+      isJscadCadModelGroupTranslucent(localizedCadModelGroup)
+    ) {
+      componentProps.push("showAsTranslucentModel")
+    }
     if (pinLabels) {
       componentProps.push(`pinLabels={${JSON.stringify(pinLabels)}}`)
     }
@@ -164,8 +180,11 @@ export const convertPcbComponents: BoardConverterStage = ({
     if (pcbComponent.obstructs_within_bounds === false) {
       componentProps.push("obstructsWithinBounds={false}")
     }
+    const chipOpeningTsx = `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}}`
     boardChildren.push(
-      `<chip ${componentProps.join(" ")} footprint={${footprintTsx ?? "<footprint />"}} />`,
+      childModelElementsTsx.length === 0
+        ? `${chipOpeningTsx} />`
+        : `${chipOpeningTsx}>${childModelElementsTsx.join("\n")}</chip>`,
     )
   }
 }

package/lib/generate-board-cad-models-tsx/converter-types.ts

@@ -1,5 +1,11 @@
 import type { CadComponent, PcbComponent } from "circuit-json"
 
+export interface Point3 {
+  x: number
+  y: number
+  z: number
+}
+
 export interface CadModelUrl {
   format: "glb" | "gltf" | "obj" | "step" | "stl" | "wrl"
   url: string

package/lib/generate-board-cad-models-tsx/execute-jscad-operation.ts

@@ -0,0 +1,7 @@
+import jscad from "@jscad/modeling"
+import { executeJscadOperations, type JscadOperation } from "jscad-planner"
+
+export function executeJscadOperation(operation: JscadOperation): unknown {
+  // @ts-expect-error @jscad/modeling overloads differ from the planner adapter.
+  return executeJscadOperations(jscad, operation)
+}

package/lib/generate-board-cad-models-tsx/generate-cad-model-group-model-tsx.ts

@@ -1,9 +1,10 @@
 import type { PcbBoard } from "circuit-json"
 import type { CadModelGroup } from "./converter-types"
 import { generateCadModelTsx } from "./generate-cad-model-tsx"
-import { generateJscadCadModelTsx } from "./generate-jscad-cad-model-tsx"
+import { generateJscadCadModelPropTsx } from "./generate-jscad-cad-model-prop-tsx"
+import { getCadModelUrl } from "./get-cad-model-url"
 
-const generateCadModelElementsTsx = ({
+const generateUrlCadModelElementsTsx = ({
   cadModelGroup,
   pcbBoard,
 }: {
@@ -11,11 +12,9 @@ const generateCadModelElementsTsx = ({
   pcbBoard: PcbBoard
 }): string[] =>
   cadModelGroup.cadComponents.flatMap((cadComponent) => {
-    const modelElementGenerator =
-      cadComponent.model_jscad === undefined
-        ? generateCadModelTsx
-        : generateJscadCadModelTsx
-    const modelElement = modelElementGenerator({
+    if (getCadModelUrl(cadComponent) === undefined) return []
+
+    const modelElement = generateCadModelTsx({
       cadComponent,
       parentPlacement: cadModelGroup.parentPlacement,
       pcbBoard,
@@ -23,6 +22,13 @@ const generateCadModelElementsTsx = ({
     return modelElement ? [modelElement] : []
   })
 
+const getJscadCadComponents = (
+  cadModelGroup: CadModelGroup,
+): CadModelGroup["cadComponents"] =>
+  cadModelGroup.cadComponents.filter(
+    (cadComponent) => cadComponent.model_jscad !== undefined,
+  )
+
 export function generateCadModelGroupModelTsx({
   cadModelGroup,
   pcbBoard,
@@ -30,12 +36,33 @@ export function generateCadModelGroupModelTsx({
   cadModelGroup: CadModelGroup
   pcbBoard: PcbBoard
 }): string | undefined {
-  const modelElements = generateCadModelElementsTsx({
+  const jscadCadComponents = getJscadCadComponents(cadModelGroup)
+  if (jscadCadComponents.length > 0) {
+    return generateJscadCadModelPropTsx({
+      cadComponents: jscadCadComponents,
+      parentPlacement: cadModelGroup.parentPlacement,
+      pcbBoard,
+    })
+  }
+
+  const urlCadModelElementsTsx = generateUrlCadModelElementsTsx({
     cadModelGroup,
     pcbBoard,
   })
-  if (modelElements.length === 0) return undefined
-  if (modelElements.length === 1) return modelElements[0]
+  if (urlCadModelElementsTsx.length === 0) return undefined
+  if (urlCadModelElementsTsx.length === 1) return urlCadModelElementsTsx[0]
+
+  return `<cadassembly>${urlCadModelElementsTsx.join("\n")}</cadassembly>`
+}
+
+export function generateCadModelGroupChildrenTsx({
+  cadModelGroup,
+  pcbBoard,
+}: {
+  cadModelGroup: CadModelGroup
+  pcbBoard: PcbBoard
+}): string[] {
+  if (getJscadCadComponents(cadModelGroup).length === 0) return []
 
-  return `<cadassembly>${modelElements.join("\n")}</cadassembly>`
+  return generateUrlCadModelElementsTsx({ cadModelGroup, pcbBoard })
 }

package/lib/generate-board-cad-models-tsx/generate-cad-model-group-tsx.ts

@@ -1,6 +1,10 @@
 import type { PcbBoard } from "circuit-json"
 import type { CadModelGroup } from "./converter-types"
-import { generateCadModelGroupModelTsx } from "./generate-cad-model-group-model-tsx"
+import {
+  generateCadModelGroupChildrenTsx,
+  generateCadModelGroupModelTsx,
+} from "./generate-cad-model-group-model-tsx"
+import { isJscadCadModelGroupTranslucent } from "./is-jscad-cad-model-group-translucent"
 
 export function generateCadModelGroupTsx({
   cadModelGroup,
@@ -29,5 +33,16 @@ export function generateCadModelGroupTsx({
     "footprint={<footprint />}",
     `cadModel={${cadModelTsx}}`,
   ]
-  return `<chip ${attributes.join(" ")} />`
+  if (isJscadCadModelGroupTranslucent(cadModelGroup)) {
+    attributes.push("showAsTranslucentModel")
+  }
+  const childModelElementsTsx = generateCadModelGroupChildrenTsx({
+    cadModelGroup,
+    pcbBoard,
+  })
+  if (childModelElementsTsx.length === 0) {
+    return `<chip ${attributes.join(" ")} />`
+  }
+
+  return `<chip ${attributes.join(" ")}>${childModelElementsTsx.join("\n")}</chip>`
 }