@things-factory/figure-ui 10.1.129 → 10.1.142

package/client/modeller/align.ts

@@ -1,6 +1,7 @@
 import { figureOccupiedBoxesOf, figureWritersOf } from '@hatiolab/figure-model'
-import { evaluatedGeometryOf } from './evaluated.js'
-import type { FigureAsset, FigureInputChange, FigureWorldBox } from '@hatiolab/figure-model'
+import type { FigureInputChange, FigureWorldBox } from '@hatiolab/figure-model'
+
+import { derivedOf, type FigureRevision } from './revision.js'
 
 import type { GizmoReach } from './gizmo.js'
 
@@ -20,16 +21,21 @@ export type AlignTool = 'centre-x' | 'centre-z' | 'snap'
 
 const AXES = ['x', 'y', 'z'] as const
 
-/** `values`: the inputs the figure is drawn with, when the box is read as drawn; left out, the asset as it is saved. */
-export function boxOf(asset: FigureAsset, part: string, values?: Record<string, number>): FigureWorldBox | undefined {
-  const geometry = evaluatedGeometryOf(asset, values)
-  return figureOccupiedBoxesOf(geometry, figureWritersOf(asset)).find(box => box.part === part)
+/**
+ * Every part's box at this version, as drawn: the pose set with the controls included, as the canvas shows it and as a
+ * command sees it (a fastening keeps a part where it is drawn).
+ */
+export function boxesOf(revision: FigureRevision): FigureWorldBox[] {
+  return derivedOf(revision, 'boxes', () => figureOccupiedBoxesOf(revision.geometry, figureWritersOf(revision.asset)))
+}
+
+export function boxOf(revision: FigureRevision, part: string): FigureWorldBox | undefined {
+  return boxesOf(revision).find(box => box.part === part)
 }
 
 /** The snapping grid: about five steps across the figure, on 1 · 2 · 5 multiples. */
-export function gridStepOf(asset: FigureAsset): number {
-  const geometry = evaluatedGeometryOf(asset)
-  const boxes = figureOccupiedBoxesOf(geometry, figureWritersOf(asset))
+export function gridStepOf(revision: FigureRevision): number {
+  const boxes = boxesOf(revision)
   if (!boxes.length) return 1
   const span = Math.max(
     ...AXES.map(axis => {
@@ -41,11 +47,11 @@ export function gridStepOf(asset: FigureAsset): number {
   return niceStep(span)
 }
 
-export function alignChanges(asset: FigureAsset, part: string, reach: GizmoReach, tool: AlignTool): FigureInputChange[] {
+export function alignChanges(revision: FigureRevision, part: string, reach: GizmoReach, tool: AlignTool): FigureInputChange[] {
   if (!reach.translate) return []
-  const box = boxOf(asset, part)
+  const box = boxOf(revision, part)
   if (!box) return []
-  const value = (id: string) => asset.designInputs[id] ?? 0
+  const value = (id: string) => revision.asset.designInputs[id] ?? 0
   const set = (input: string, next: number): FigureInputChange => ({ kind: 'set-design', input, unit: 'mm', value: Math.round(next) })
   const at = (axis: 'x' | 'y' | 'z') => `${part}.position.${axis}`
   switch (tool) {
@@ -54,7 +60,7 @@ export function alignChanges(asset: FigureAsset, part: string, reach: GizmoReach
     case 'centre-z':
       return [set(at('z'), value(at('z')) - box.centre.z)]
     case 'snap': {
-      const step = gridStepOf(asset)
+      const step = gridStepOf(revision)
       const round = (n: number) => Math.round(n / step) * step
       const changes = AXES.map(axis => set(at(axis), round(value(at(axis)))))
       /* A size never snaps to 0 — the part would look gone. */
@@ -69,16 +75,16 @@ export function alignChanges(asset: FigureAsset, part: string, reach: GizmoReach
  * Where a mirrored copy goes: the same distance on the other side of the centre plane. The copy is made by
  * `duplicate-part` first; this is the position the copy is then given.
  */
-export function mirrorChanges(asset: FigureAsset, part: string, copy: string, axis: 'x' | 'z'): FigureInputChange[] {
-  const box = boxOf(asset, part)
+export function mirrorChanges(revision: FigureRevision, part: string, copy: string, axis: 'x' | 'z'): FigureInputChange[] {
+  const box = boxOf(revision, part)
   if (!box) return []
   const id = `${part}.position.${axis}`
-  return [{ kind: 'set-design', input: `${copy}.position.${axis}`, unit: 'mm', value: Math.round((asset.designInputs[id] ?? 0) - 2 * box.centre[axis]) }]
+  return [{ kind: 'set-design', input: `${copy}.position.${axis}`, unit: 'mm', value: Math.round((revision.asset.designInputs[id] ?? 0) - 2 * box.centre[axis]) }]
 }
 
 /** Mirroring a part that already sits on the centre plane would put the copy inside it, so it is refused. */
-export function canMirror(asset: FigureAsset, part: string, axis: 'x' | 'z', reach: GizmoReach): boolean {
-  const box = reach.translate ? boxOf(asset, part) : undefined
+export function canMirror(revision: FigureRevision, part: string, axis: 'x' | 'z', reach: GizmoReach): boolean {
+  const box = reach.translate ? boxOf(revision, part) : undefined
   return !!box && Math.abs(box.centre[axis]) >= 0.5
 }