@pascal-app/editor 1.1.0 → 1.1.1

package/src/components/editor-2d/renderers/floorplan-dimension-renderer.tsx

@@ -1,708 +0,0 @@
-import type { FloorplanGeometry, FloorplanPoint } from '@pascal-app/core'
-import { useDimensionEditAllowed } from './floorplan-dimension-edit-overlay'
-import { resolveFloorplanLabelAngle } from './floorplan-label-angle'
-
-const EXTENSION_START_GAP = 0.075
-const TICK_HALF_LENGTH = 0.09
-const LABEL_FONT_SIZE = 0.15
-const LABEL_BASELINE_OFFSET = 0.12
-const LABEL_CHARACTER_WIDTH_RATIO = 0.62
-const LABEL_END_GAP = 0.075
-const DOCUMENT_EXTENSION_START_GAP_PT = 3
-const DOCUMENT_EXTENSION_OVERSHOOT_PT = 4
-const DOCUMENT_TICK_HALF_LENGTH_PT = 4.5
-const DOCUMENT_LABEL_FONT_SIZE_PT = 8
-const DOCUMENT_LABEL_BASELINE_OFFSET_PT = 5
-const DOCUMENT_LABEL_END_GAP_PT = 3
-const LINE_STROKE_WIDTH_PX = 0.9
-const TICK_STROKE_WIDTH_PX = 1.35
-const PDF_LINE_STROKE_WIDTH_PT = 0.5
-const PDF_TICK_STROKE_WIDTH_PT = 0.75
-const SQRT_ONE_HALF = Math.SQRT1_2
-
-type FloorplanDimensionRenderMode = 'screen' | 'pdf'
-
-/**
- * Click-to-type dimensions (WS3).
- *
- * On screen the label plate carries an invisible hit rect plus the data the
- * editing layer needs to drive geometry from a typed value. The layer picks
- * it up by DOM delegation (`FloorplanDimensionEditOverlay` below), so every
- * producer of `dimension` / `dimension-string` geometry — wall automatic
- * dimensions, contextual dimensions, manual construction-dimension nodes —
- * becomes editable without each one wiring up a callback.
- *
- * Witness points are the measured feature points in level-plan metres; the
- * value is the length the label actually reads (dimension-line points when
- * the producer supplied them, witness points otherwise).
- */
-export const FLOORPLAN_DIMENSION_HIT_ATTRIBUTE = 'data-floorplan-dimension-hit'
-
-type DimensionGeometry = Extract<FloorplanGeometry, { kind: 'dimension' }>
-type DimensionStringGeometry = Extract<FloorplanGeometry, { kind: 'dimension-string' }>
-type DimensionTerminator = NonNullable<DimensionGeometry['terminator']>
-
-export type ArchitecturalDimensionLayout = {
-  dimensionStart: FloorplanPoint
-  dimensionEnd: FloorplanPoint
-  dimensionLineStart: FloorplanPoint
-  dimensionLineEnd: FloorplanPoint
-  extensionStart: FloorplanPoint
-  extensionEnd: FloorplanPoint
-  extensionStartTip: FloorplanPoint
-  extensionEndTip: FloorplanPoint
-  tickHalfVector: FloorplanPoint
-  labelPoint: FloorplanPoint
-  labelAngleDeg: number
-  labelPlacement: 'inside' | 'outside-end'
-  outsideStartLabelPoint?: FloorplanPoint
-  outsideStartDimensionLineStart?: FloorplanPoint
-}
-
-export function floorplanDimensionAnnotationPriority(offsetDistance: number): number {
-  return 100 + Math.round(Math.abs(offsetDistance) * 100)
-}
-
-export function computeArchitecturalDimensionLayout(
-  geometry: DimensionGeometry,
-  sceneRotationDeg: number,
-  annotationUnitsPerPoint?: number,
-): ArchitecturalDimensionLayout | null {
-  const extensionStartGap = annotationUnitsPerPoint
-    ? DOCUMENT_EXTENSION_START_GAP_PT * annotationUnitsPerPoint
-    : (geometry.extensionStartGap ?? EXTENSION_START_GAP)
-  const extensionOvershoot = annotationUnitsPerPoint
-    ? DOCUMENT_EXTENSION_OVERSHOOT_PT * annotationUnitsPerPoint
-    : geometry.extensionOvershoot
-  const tickHalfLength = annotationUnitsPerPoint
-    ? DOCUMENT_TICK_HALF_LENGTH_PT * annotationUnitsPerPoint
-    : TICK_HALF_LENGTH
-  const labelFontSize = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
-    : LABEL_FONT_SIZE
-  const labelEndGap = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_END_GAP_PT * annotationUnitsPerPoint
-    : LABEL_END_GAP
-  const offsetX = geometry.offsetNormal[0] * geometry.offsetDistance
-  const offsetY = geometry.offsetNormal[1] * geometry.offsetDistance
-  const dimensionStart: FloorplanPoint = geometry.dimensionStart ?? [
-    geometry.start[0] + offsetX,
-    geometry.start[1] + offsetY,
-  ]
-  const dimensionEnd: FloorplanPoint = geometry.dimensionEnd ?? [
-    geometry.end[0] + offsetX,
-    geometry.end[1] + offsetY,
-  ]
-  const dx = dimensionEnd[0] - dimensionStart[0]
-  const dy = dimensionEnd[1] - dimensionStart[1]
-  const length = Math.hypot(dx, dy)
-  if (length < 1e-6) return null
-
-  const dirX = dx / length
-  const dirY = dy / length
-  const startOffsetDistance = dot(subtract(dimensionStart, geometry.start), geometry.offsetNormal)
-  const endOffsetDistance = dot(subtract(dimensionEnd, geometry.end), geometry.offsetNormal)
-  const startExtensionGap = Math.min(extensionStartGap, Math.max(0, startOffsetDistance - 0.01))
-  const endExtensionGap = Math.min(extensionStartGap, Math.max(0, endOffsetDistance - 0.01))
-
-  // A 45-degree architectural slash. Every terminator within one string uses
-  // this same vector instead of rotating independently around its endpoint.
-  const tickHalfVector: FloorplanPoint = [
-    (dirX + dirY) * tickHalfLength * SQRT_ONE_HALF,
-    (dirY - dirX) * tickHalfLength * SQRT_ONE_HALF,
-  ]
-  const labelWidth = Math.max(
-    labelFontSize,
-    geometry.text.length * labelFontSize * LABEL_CHARACTER_WIDTH_RATIO,
-  )
-  const labelPlacement =
-    length >= labelWidth + labelEndGap * 2 ? ('inside' as const) : ('outside-end' as const)
-  const direction: FloorplanPoint = [dirX, dirY]
-  const labelPoint =
-    labelPlacement === 'inside'
-      ? ([
-          (dimensionStart[0] + dimensionEnd[0]) / 2,
-          (dimensionStart[1] + dimensionEnd[1]) / 2,
-        ] as FloorplanPoint)
-      : addScaled(dimensionEnd, direction, labelEndGap + labelWidth / 2)
-  const dimensionLineEnd =
-    labelPlacement === 'inside'
-      ? dimensionEnd
-      : addScaled(dimensionEnd, direction, labelEndGap * 2 + labelWidth)
-  const outsideStartLabelPoint =
-    labelPlacement === 'outside-end'
-      ? addScaled(dimensionStart, direction, -(labelEndGap + labelWidth / 2))
-      : undefined
-  const outsideStartDimensionLineStart =
-    labelPlacement === 'outside-end'
-      ? addScaled(dimensionStart, direction, -(labelEndGap * 2 + labelWidth))
-      : undefined
-
-  return {
-    dimensionStart,
-    dimensionEnd,
-    dimensionLineStart: dimensionStart,
-    dimensionLineEnd,
-    extensionStart: addScaled(geometry.start, geometry.offsetNormal, startExtensionGap),
-    extensionEnd: addScaled(geometry.end, geometry.offsetNormal, endExtensionGap),
-    extensionStartTip: addScaled(dimensionStart, geometry.offsetNormal, extensionOvershoot),
-    extensionEndTip: addScaled(dimensionEnd, geometry.offsetNormal, extensionOvershoot),
-    tickHalfVector,
-    labelPoint,
-    labelAngleDeg: resolveFloorplanLabelAngle(Math.atan2(dy, dx), sceneRotationDeg),
-    labelPlacement,
-    outsideStartLabelPoint,
-    outsideStartDimensionLineStart,
-  }
-}
-
-function subtract(left: FloorplanPoint, right: FloorplanPoint): FloorplanPoint {
-  return [left[0] - right[0], left[1] - right[1]]
-}
-
-function dot(left: FloorplanPoint, right: FloorplanPoint): number {
-  return left[0] * right[0] + left[1] * right[1]
-}
-
-function addScaled(
-  point: FloorplanPoint,
-  direction: FloorplanPoint,
-  distance: number,
-): FloorplanPoint {
-  return [point[0] + direction[0] * distance, point[1] + direction[1] * distance]
-}
-
-export function FloorplanDimensionRenderer({
-  geometry,
-  sceneRotationDeg = 0,
-  stroke = geometry.stroke ?? '#334155',
-  annotationUnitsPerPoint,
-  renderMode = 'screen',
-  onSelect,
-}: {
-  geometry: DimensionGeometry
-  sceneRotationDeg?: number
-  stroke?: string
-  annotationUnitsPerPoint?: number
-  renderMode?: FloorplanDimensionRenderMode
-  onSelect?: () => void
-}): React.ReactElement | null {
-  const layout = computeArchitecturalDimensionLayout(
-    geometry,
-    sceneRotationDeg,
-    annotationUnitsPerPoint,
-  )
-  if (!layout) return null
-
-  const labelFontSize = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
-    : LABEL_FONT_SIZE
-  const labelBaselineOffset = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
-    : LABEL_BASELINE_OFFSET
-  const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset
-
-  const lineProps = {
-    stroke,
-    strokeLinecap: 'butt' as const,
-    strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
-    vectorEffect: 'non-scaling-stroke' as const,
-  }
-  const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX
-  const terminator = geometry.terminator ?? 'architectural-tick'
-  const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`
-  const outsideStartLocalShift = layout.outsideStartLabelPoint
-    ? rotateVector(
-        subtract(layout.outsideStartLabelPoint, layout.labelPoint),
-        (-layout.labelAngleDeg * Math.PI) / 180,
-      )
-    : undefined
-
-  return (
-    <g
-      data-floorplan-dimension=""
-      onClick={
-        onSelect
-          ? (event) => {
-              event.stopPropagation()
-              onSelect()
-            }
-          : undefined
-      }
-      pointerEvents={onSelect ? 'auto' : 'none'}
-    >
-      <line
-        {...lineProps}
-        x1={layout.extensionStart[0]}
-        x2={layout.extensionStartTip[0]}
-        y1={layout.extensionStart[1]}
-        y2={layout.extensionStartTip[1]}
-      />
-      <line
-        {...lineProps}
-        x1={layout.extensionEnd[0]}
-        x2={layout.extensionEndTip[0]}
-        y1={layout.extensionEnd[1]}
-        y2={layout.extensionEndTip[1]}
-      />
-      <line
-        {...lineProps}
-        data-floorplan-dimension-default-x1={layout.dimensionLineStart[0]}
-        data-floorplan-dimension-default-x2={layout.dimensionLineEnd[0]}
-        data-floorplan-dimension-default-y1={layout.dimensionLineStart[1]}
-        data-floorplan-dimension-default-y2={layout.dimensionLineEnd[1]}
-        data-floorplan-dimension-line=""
-        data-floorplan-dimension-outside-start-x1={layout.outsideStartDimensionLineStart?.[0]}
-        data-floorplan-dimension-outside-start-x2={layout.dimensionEnd[0]}
-        data-floorplan-dimension-outside-start-y1={layout.outsideStartDimensionLineStart?.[1]}
-        data-floorplan-dimension-outside-start-y2={layout.dimensionEnd[1]}
-        x1={layout.dimensionLineStart[0]}
-        x2={layout.dimensionLineEnd[0]}
-        y1={layout.dimensionLineStart[1]}
-        y2={layout.dimensionLineEnd[1]}
-      />
-      {renderTerminator(
-        terminator,
-        layout.dimensionStart,
-        layout.dimensionEnd,
-        layout,
-        lineProps,
-        tickStrokeWidth,
-      )}
-      {renderTerminator(
-        terminator,
-        layout.dimensionEnd,
-        layout.dimensionStart,
-        layout,
-        lineProps,
-        tickStrokeWidth,
-      )}
-      {layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (
-        <line
-          {...lineProps}
-          data-floorplan-dimension-leader=""
-          visibility="hidden"
-          x1={layout.dimensionEnd[0]}
-          x2={layout.labelPoint[0]}
-          y1={layout.dimensionEnd[1]}
-          y2={layout.labelPoint[1]}
-        />
-      ) : null}
-      <g
-        data-floorplan-annotation-angle-radians={Math.atan2(
-          geometry.end[1] - geometry.start[1],
-          geometry.end[0] - geometry.start[0],
-        )}
-        data-floorplan-annotation-default-transform={labelTransform}
-        data-floorplan-annotation-label=""
-        data-floorplan-annotation-priority={floorplanDimensionAnnotationPriority(
-          geometry.offsetDistance,
-        )}
-        data-floorplan-annotation-transform-before-rotation={`translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`}
-        data-floorplan-dimension-label-placement={layout.labelPlacement}
-        data-floorplan-dimension-outside-start-local-x={outsideStartLocalShift?.[0]}
-        data-floorplan-dimension-outside-start-local-y={outsideStartLocalShift?.[1]}
-        data-floorplan-dimension-start-x={layout.dimensionStart[0]}
-        data-floorplan-dimension-start-y={layout.dimensionStart[1]}
-        data-floorplan-dimension-end-x={layout.dimensionEnd[0]}
-        data-floorplan-dimension-end-y={layout.dimensionEnd[1]}
-        data-floorplan-dimension-text={geometry.text}
-        data-floorplan-dimension-value={dimensionLabelValue(layout)}
-        data-floorplan-dimension-witness-start-x={geometry.start[0]}
-        data-floorplan-dimension-witness-start-y={geometry.start[1]}
-        data-floorplan-dimension-witness-end-x={geometry.end[0]}
-        data-floorplan-dimension-witness-end-y={geometry.end[1]}
-        transform={labelTransform}
-      >
-        <DimensionLabel
-          fontSize={labelFontSize}
-          // `overridden` is declared on the geometry union in
-          // packages/core/src/registry/types.ts; the cast keeps this file
-          // compiling against a core dist built before that field landed.
-          overridden={(geometry as { overridden?: boolean }).overridden === true}
-          renderMode={renderMode}
-          stroke={stroke}
-          text={geometry.text}
-          y={labelY}
-        />
-      </g>
-    </g>
-  )
-}
-
-export function FloorplanDimensionStringRenderer({
-  geometry,
-  sceneRotationDeg = 0,
-  stroke = geometry.stroke ?? '#334155',
-  annotationUnitsPerPoint,
-  renderMode = 'screen',
-}: {
-  geometry: DimensionStringGeometry
-  sceneRotationDeg?: number
-  stroke?: string
-  annotationUnitsPerPoint?: number
-  renderMode?: FloorplanDimensionRenderMode
-}): React.ReactElement | null {
-  const segmentLayouts = geometry.segments.flatMap((segment, index) => {
-    const segmentGeometry: DimensionGeometry = {
-      kind: 'dimension',
-      start: segment.start,
-      end: segment.end,
-      dimensionStart: segment.dimensionStart,
-      dimensionEnd: segment.dimensionEnd,
-      offsetNormal: geometry.offsetNormal,
-      offsetDistance: geometry.offsetDistance,
-      extensionOvershoot: geometry.extensionOvershoot,
-      extensionStartGap: geometry.extensionStartGap,
-      terminator: geometry.terminator,
-      textPosition: geometry.textPosition,
-      text: segment.text,
-      stroke: geometry.stroke,
-    }
-    const layout = computeArchitecturalDimensionLayout(
-      segmentGeometry,
-      sceneRotationDeg,
-      annotationUnitsPerPoint,
-    )
-    return layout ? [{ index, layout, segment: segmentGeometry }] : []
-  })
-  if (segmentLayouts.length === 0) return null
-
-  const labelFontSize = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_FONT_SIZE_PT * annotationUnitsPerPoint
-    : LABEL_FONT_SIZE
-  const labelBaselineOffset = annotationUnitsPerPoint
-    ? DOCUMENT_LABEL_BASELINE_OFFSET_PT * annotationUnitsPerPoint
-    : LABEL_BASELINE_OFFSET
-  const labelY = geometry.textPosition === 'centered' ? labelFontSize * 0.35 : -labelBaselineOffset
-  const lineProps = {
-    stroke,
-    strokeLinecap: 'butt' as const,
-    strokeWidth: renderMode === 'pdf' ? PDF_LINE_STROKE_WIDTH_PT : LINE_STROKE_WIDTH_PX,
-    vectorEffect: 'non-scaling-stroke' as const,
-  }
-  const tickStrokeWidth = renderMode === 'pdf' ? PDF_TICK_STROKE_WIDTH_PT : TICK_STROKE_WIDTH_PX
-
-  const extensionLines = new Map<string, { start: FloorplanPoint; tip: FloorplanPoint }>()
-  const ticks = new Map<
-    string,
-    { point: FloorplanPoint; toward: FloorplanPoint; tickHalfVector: FloorplanPoint }
-  >()
-  for (const { layout } of segmentLayouts) {
-    extensionLines.set(pointKey(layout.dimensionStart), {
-      start: layout.extensionStart,
-      tip: layout.extensionStartTip,
-    })
-    extensionLines.set(pointKey(layout.dimensionEnd), {
-      start: layout.extensionEnd,
-      tip: layout.extensionEndTip,
-    })
-    ticks.set(pointKey(layout.dimensionStart), {
-      point: layout.dimensionStart,
-      toward: layout.dimensionEnd,
-      tickHalfVector: layout.tickHalfVector,
-    })
-    ticks.set(pointKey(layout.dimensionEnd), {
-      point: layout.dimensionEnd,
-      toward: layout.dimensionStart,
-      tickHalfVector: layout.tickHalfVector,
-    })
-  }
-  const terminator = geometry.terminator ?? 'architectural-tick'
-
-  return (
-    <g data-floorplan-dimension-string="" pointerEvents="none">
-      {[...extensionLines.values()].map((line, index) => (
-        <line
-          {...lineProps}
-          key={`extension-${index}`}
-          x1={line.start[0]}
-          x2={line.tip[0]}
-          y1={line.start[1]}
-          y2={line.tip[1]}
-        />
-      ))}
-      {segmentLayouts.map(({ index, layout }) => (
-        <line
-          {...lineProps}
-          data-floorplan-dimension-default-x1={layout.dimensionLineStart[0]}
-          data-floorplan-dimension-default-x2={layout.dimensionLineEnd[0]}
-          data-floorplan-dimension-default-y1={layout.dimensionLineStart[1]}
-          data-floorplan-dimension-default-y2={layout.dimensionLineEnd[1]}
-          data-floorplan-dimension-line=""
-          data-floorplan-dimension-outside-start-x1={layout.outsideStartDimensionLineStart?.[0]}
-          data-floorplan-dimension-outside-start-x2={layout.dimensionEnd[0]}
-          data-floorplan-dimension-outside-start-y1={layout.outsideStartDimensionLineStart?.[1]}
-          data-floorplan-dimension-outside-start-y2={layout.dimensionEnd[1]}
-          key={`dimension-line-${index}`}
-          x1={layout.dimensionLineStart[0]}
-          x2={layout.dimensionLineEnd[0]}
-          y1={layout.dimensionLineStart[1]}
-          y2={layout.dimensionLineEnd[1]}
-        />
-      ))}
-      {[...ticks.values()].map(({ point, toward, tickHalfVector }, index) =>
-        renderTerminator(
-          terminator,
-          point,
-          toward,
-          { tickHalfVector },
-          lineProps,
-          tickStrokeWidth,
-          `tick-${index}`,
-        ),
-      )}
-      {segmentLayouts.map(({ index, layout, segment }) => {
-        const labelTransform = `translate(${layout.labelPoint[0]} ${layout.labelPoint[1]}) rotate(${layout.labelAngleDeg})`
-        const outsideStartLocalShift = layout.outsideStartLabelPoint
-          ? rotateVector(
-              subtract(layout.outsideStartLabelPoint, layout.labelPoint),
-              (-layout.labelAngleDeg * Math.PI) / 180,
-            )
-          : undefined
-        return (
-          <g key={`label-${index}`}>
-            {layout.labelPlacement === 'outside-end' && annotationUnitsPerPoint !== undefined ? (
-              <line
-                {...lineProps}
-                data-floorplan-dimension-leader=""
-                visibility="hidden"
-                x1={layout.dimensionEnd[0]}
-                x2={layout.labelPoint[0]}
-                y1={layout.dimensionEnd[1]}
-                y2={layout.labelPoint[1]}
-              />
-            ) : null}
-            <g
-              data-floorplan-annotation-angle-radians={Math.atan2(
-                segment.end[1] - segment.start[1],
-                segment.end[0] - segment.start[0],
-              )}
-              data-floorplan-annotation-default-transform={labelTransform}
-              data-floorplan-annotation-label=""
-              data-floorplan-annotation-priority={floorplanDimensionAnnotationPriority(
-                geometry.offsetDistance,
-              )}
-              data-floorplan-annotation-transform-before-rotation={`translate(${layout.labelPoint[0]} ${layout.labelPoint[1]})`}
-              data-floorplan-dimension-label-placement={layout.labelPlacement}
-              data-floorplan-dimension-outside-start-local-x={outsideStartLocalShift?.[0]}
-              data-floorplan-dimension-outside-start-local-y={outsideStartLocalShift?.[1]}
-              data-floorplan-dimension-start-x={layout.dimensionStart[0]}
-              data-floorplan-dimension-start-y={layout.dimensionStart[1]}
-              data-floorplan-dimension-end-x={layout.dimensionEnd[0]}
-              data-floorplan-dimension-end-y={layout.dimensionEnd[1]}
-              data-floorplan-dimension-text={segment.text}
-              data-floorplan-dimension-value={dimensionLabelValue(layout)}
-              data-floorplan-dimension-witness-start-x={segment.start[0]}
-              data-floorplan-dimension-witness-start-y={segment.start[1]}
-              data-floorplan-dimension-witness-end-x={segment.end[0]}
-              data-floorplan-dimension-witness-end-y={segment.end[1]}
-              transform={labelTransform}
-            >
-              <DimensionLabel
-                fontSize={labelFontSize}
-                renderMode={renderMode}
-                stroke={stroke}
-                text={segment.text}
-                y={labelY}
-              />
-            </g>
-          </g>
-        )
-      })}
-    </g>
-  )
-}
-
-/** The length the label reads — the dimension-line span, offset cancels out. */
-function dimensionLabelValue(layout: ArchitecturalDimensionLayout): number {
-  return Math.hypot(
-    layout.dimensionEnd[0] - layout.dimensionStart[0],
-    layout.dimensionEnd[1] - layout.dimensionStart[1],
-  )
-}
-
-function rotateVector(vector: FloorplanPoint, radians: number): FloorplanPoint {
-  const cosine = Math.cos(radians)
-  const sine = Math.sin(radians)
-  return [vector[0] * cosine - vector[1] * sine, vector[0] * sine + vector[1] * cosine]
-}
-
-function DimensionLabel({
-  text,
-  y,
-  fontSize,
-  stroke,
-  renderMode,
-  overridden = false,
-}: {
-  text: string
-  y: number
-  fontSize: number
-  stroke: string
-  renderMode: FloorplanDimensionRenderMode
-  /** Draws the "override" badge when the value could not drive geometry. */
-  overridden?: boolean
-}) {
-  const width = Math.max(fontSize, text.length * fontSize * LABEL_CHARACTER_WIDTH_RATIO)
-  const plateWidth = width + fontSize * 0.5
-  const plateHeight = fontSize * 1.2
-  const plateY = y - fontSize * 0.82
-  const editable = useDimensionEditAllowed()
-
-  return (
-    <>
-      {renderMode === 'pdf' ? (
-        <rect
-          data-floorplan-dimension-label-plate=""
-          fill="#ffffff"
-          height={plateHeight}
-          rx={fontSize * 0.12}
-          ry={fontSize * 0.12}
-          width={plateWidth}
-          x={-plateWidth / 2}
-          y={plateY}
-        />
-      ) : null}
-      <text
-        fill={stroke}
-        fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
-        fontSize={fontSize}
-        fontWeight={500}
-        paintOrder={renderMode === 'pdf' ? undefined : 'stroke'}
-        stroke={renderMode === 'pdf' ? undefined : '#ffffff'}
-        strokeLinejoin={renderMode === 'pdf' ? undefined : 'round'}
-        strokeWidth={renderMode === 'pdf' ? undefined : 3}
-        textAnchor="middle"
-        vectorEffect={renderMode === 'pdf' ? undefined : 'non-scaling-stroke'}
-        x={0}
-        y={y}
-      >
-        {text}
-      </text>
-      {overridden && renderMode !== 'pdf' ? (
-        <text
-          fill={stroke}
-          fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
-          fontSize={fontSize * 0.62}
-          opacity={0.75}
-          paintOrder="stroke"
-          stroke="#ffffff"
-          strokeLinejoin="round"
-          strokeWidth={2}
-          textAnchor="middle"
-          vectorEffect="non-scaling-stroke"
-          x={0}
-          y={y + fontSize * 0.86}
-        >
-          override
-        </text>
-      ) : null}
-      {renderMode === 'pdf' || !editable ? null : (
-        // Invisible click target on the plate. `pointer-events` is inherited
-        // from the dimension group (`none`), so it is re-enabled here only.
-        <rect
-          {...{ [FLOORPLAN_DIMENSION_HIT_ATTRIBUTE]: '' }}
-          cursor="text"
-          fill="transparent"
-          height={plateHeight}
-          pointerEvents="all"
-          width={plateWidth}
-          x={-plateWidth / 2}
-          y={plateY}
-        />
-      )}
-    </>
-  )
-}
-
-function renderTerminator(
-  terminator: DimensionTerminator,
-  point: FloorplanPoint,
-  toward: FloorplanPoint,
-  layout: Pick<ArchitecturalDimensionLayout, 'tickHalfVector'>,
-  lineProps: {
-    stroke: string
-    strokeLinecap: 'butt'
-    strokeWidth: number
-    vectorEffect: 'non-scaling-stroke'
-  },
-  tickStrokeWidth: number,
-  key?: string,
-): React.ReactElement | null {
-  const direction = normalized(point, toward)
-  if (!direction) return null
-  const tickHalfLength = Math.hypot(layout.tickHalfVector[0], layout.tickHalfVector[1])
-  if (terminator === 'dot') {
-    return (
-      <circle
-        fill={lineProps.stroke}
-        key={key}
-        r={tickHalfLength * 0.45}
-        vectorEffect="non-scaling-stroke"
-        cx={point[0]}
-        cy={point[1]}
-      />
-    )
-  }
-  if (terminator === 'filled-arrow' || terminator === 'open-arrow') {
-    const base = addScaled(point, direction, tickHalfLength * 1.7)
-    const normal: FloorplanPoint = [-direction[1], direction[0]]
-    const wing = tickHalfLength * 0.65
-    const left: FloorplanPoint = [base[0] + normal[0] * wing, base[1] + normal[1] * wing]
-    const right: FloorplanPoint = [base[0] - normal[0] * wing, base[1] - normal[1] * wing]
-    if (terminator === 'filled-arrow') {
-      return (
-        <polygon
-          fill={lineProps.stroke}
-          key={key}
-          points={`${point[0]},${point[1]} ${left[0]},${left[1]} ${right[0]},${right[1]}`}
-          vectorEffect="non-scaling-stroke"
-        />
-      )
-    }
-    return (
-      <g key={key}>
-        <line
-          {...lineProps}
-          strokeWidth={tickStrokeWidth}
-          x1={point[0]}
-          x2={left[0]}
-          y1={point[1]}
-          y2={left[1]}
-        />
-        <line
-          {...lineProps}
-          strokeWidth={tickStrokeWidth}
-          x1={point[0]}
-          x2={right[0]}
-          y1={point[1]}
-          y2={right[1]}
-        />
-      </g>
-    )
-  }
-  const [tickX, tickY] = layout.tickHalfVector
-  return (
-    <line
-      {...lineProps}
-      key={key}
-      strokeWidth={tickStrokeWidth}
-      x1={point[0] - tickX}
-      x2={point[0] + tickX}
-      y1={point[1] - tickY}
-      y2={point[1] + tickY}
-    />
-  )
-}
-
-function normalized(start: FloorplanPoint, end: FloorplanPoint): FloorplanPoint | null {
-  const dx = end[0] - start[0]
-  const dy = end[1] - start[1]
-  const magnitude = Math.hypot(dx, dy)
-  return magnitude <= 1e-6 ? null : [dx / magnitude, dy / magnitude]
-}
-
-function pointKey(point: FloorplanPoint): string {
-  return `${point[0].toFixed(6)},${point[1].toFixed(6)}`
-}