@things-factory/figure-ui 10.1.208 → 10.1.211

package/test/links.test.ts

@@ -67,7 +67,7 @@ test('움직임 — 미끄러짐 · 돌기, 축, 무엇이 모느냐를 읽는
   const turning = moving(asset, 'block', { kind: 'turn', axis: 'y', id: 'swing', min: -90, max: 90, start: 0 })
   assert.deepEqual([motionOf(turning, 'block')!.kind, motionOf(turning, 'block')!.axis], ['turn', 'y'])
   const joint = sliding.joints!.find(j => j.body1.part === 'block')!
-  const still = applyFigureAuthoring(sliding, { kind: 'set-joint', joint: { id: joint.id, type: 'fixed', body0: joint.body0, body1: joint.body1 } })
+  const still = applyFigureAuthoring(sliding, { kind: 'set-joint', joint: { id: joint.id, body0: joint.body0, body1: joint.body1 } })
   assert.equal(motionOf(still, 'block'), undefined, 'a fixed joint does not move')
 })
 
@@ -256,7 +256,7 @@ test('한 비율로 커지는 도형 — 자기 숫자인 길이를 세고, 한
   asset = applyFigureAuthoring(asset, { kind: 'scale-uniformly' })
   assert.deepEqual(proportionToFollow(asset), { count: 3 + 3 + 1, kept: [] }, '치수 여섯과 자리 하나')
   const lamp = asset.joints!.find(j => j.id === 'lamp')!
-  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...lamp, type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } } })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...lamp, motion: [{ type: 'prismatic', axis: 'Y', lowerLimit: 0, upperLimit: 50, state: { id: 'rise' } }] } })
   asset = applyFigureAuthoring(asset, { kind: 'follow-size-in-proportion' })
   assert.deepEqual(proportionToFollow(asset), { count: 0, kept: ['lamp.motion'] }, '다 따르고, mm 로 움직이는 것만 남는다')
   assert.equal(Math.round(valueNow(revisionOf(asset), 'lamp.dimension.x.value')! * 1e6) / 1e6, 60, '따르게 해도 지금 크기는 그대로')
@@ -359,9 +359,9 @@ test('따라 움직이는 관절 — 같은 방식으로 움직이고 제 조작
   assert.deepEqual(leadersFor(asset, 'left', 'slide'), [], '제 관절은 고르지 않는다')
 
   const follower = motionJoint(jointOf('right'), { ...form, id: 'ignored', follow: 'left', multiplier: -1 }, 'right')
-  assert.deepEqual(follower.mimic, { joint: 'left', multiplier: -1 })
-  assert.equal(follower.state, undefined, '따라가는 관절은 제 조작값이 없다')
-  assert.equal(follower.lowerLimit, undefined)
+  assert.deepEqual(follower.motion![0]!.mimic, { motion: 'left', multiplier: -1 })
+  assert.equal(follower.motion![0]!.state, undefined, '따라가는 관절은 제 조작값이 없다')
+  assert.equal(follower.motion![0]!.lowerLimit, undefined)
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: follower })
   assert.deepEqual(leadersFor(asset, 'wrist', 'slide').map(j => j.id), ['left'], '따라가는 관절은 앞장서지 않는다')
 
@@ -477,8 +477,8 @@ test('미끄러짐의 이동 거리가 부품 길이를 따른다 — 레일이
   const joint = asset.joints!.find(j => j.body1.part === 'bridge')!
   const form = { kind: 'slide' as const, axis: 'x' as const, id: 'x', min: 0, max: 500, follow: '', multiplier: 1, offset: 0, travel: 'rail:x', travelPlus: -160 }
   const record = motionJoint(joint, form, 'bridge')
-  assert.deepEqual(record.travel, { source: { of: 'part', part: 'rail', axis: 'x' }, plus: -160 })
-  assert.equal(record.lowerLimit, undefined, '거리는 레일이 정한다 — mm 범위는 없다')
+  assert.deepEqual(record.motion![0]!.travel, { source: { of: 'part', part: 'rail', axis: 'x' }, plus: -160 })
+  assert.equal(record.motion![0]!.lowerLimit, undefined, '거리는 레일이 정한다 — mm 범위는 없다')
   asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: record })
   assert.deepEqual(motionOf(asset, 'bridge')?.travel, { part: 'rail', axis: 'x', plus: -160 }, '화면은 무엇을 따르는지 읽는다')
   const end = (railLength: number) => {
@@ -517,7 +517,7 @@ test('선언할 크기는 부품이 쉬고 있을 때의 크기 — 문짝이
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'jamb', to: { plane: 'mounting-plane' } })
   asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'leaf', to: { part: 'jamb', face: 'right' }, align: { y: 'min', z: 'max' }, gap: 5 })
   const j = asset.joints!.find(o => o.id === 'leaf')!
-  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } } })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: { ...j, motion: [{ type: 'revolute', axis: 'Y', lowerLimit: -90, upperLimit: 0, state: { id: 'open' } }] } })
   assert.deepEqual(instanceSizeToDeclare(asset)!.at, { x: 995, y: 2100, z: 150 })
 })
 
@@ -534,20 +534,21 @@ test('움직임은 그 자리에서 고친다 — 폼에 지금 관절을 채우
   const { motionFormOf, motionJoint } = await import('../client/modeller/links.ts')
   const base = { id: 'j', body0: { part: 'a', face: 'top' as const }, body1: { part: 'b' } }
   const joints = [
-    { ...base, type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } },
-    { ...base, type: 'revolute' as const, axis: 'Y' as const, lowerLimit: -90, upperLimit: 0, state: { id: 'open' } },
-    { ...base, type: 'revolute' as const, axis: 'Y' as const, state: { id: 'spin' } },
-    { ...base, type: 'prismatic' as const, axis: 'X' as const, mimic: { joint: 'k', multiplier: -1 } },
-    { ...base, type: 'prismatic' as const, axis: 'X' as const, travel: { source: { of: 'part' as const, part: 'rail', axis: 'x' as const }, plus: -160 }, state: { id: 'x' } }
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'Z' as const, lowerLimit: 0, upperLimit: 2500, state: { id: 'extend' } }] },
+    { ...base, motion: [{ type: 'revolute' as const, axis: 'Y' as const, lowerLimit: -90, upperLimit: 0, state: { id: 'open' } }] },
+    { ...base, motion: [{ type: 'revolute' as const, axis: 'Y' as const, state: { id: 'spin' } }] },
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'X' as const, mimic: { motion: 'k', multiplier: -1 } }] },
+    { ...base, motion: [{ type: 'prismatic' as const, axis: 'X' as const, travel: { source: { of: 'part' as const, part: 'rail', axis: 'x' as const }, plus: -160 }, state: { id: 'x' } }] }
   ]
   for (const joint of joints) {
     const form = motionFormOf(joint)
-    assert.deepEqual(motionJoint(joint, form, 'b'), joint, `${joint.type} ${JSON.stringify(joint.mimic ?? joint.travel ?? joint.lowerLimit ?? 'endless')}`)
+    const a = joint.motion[0]!
+    assert.deepEqual(motionJoint(joint, form, 'b'), joint, `${a.type} ${JSON.stringify(a.mimic ?? a.travel ?? a.lowerLimit ?? 'endless')}`)
   }
   /* A leader's stroke made to follow the base's length, where it is. */
   const changed = motionJoint(joints[0]!, { ...motionFormOf(joints[0]!), travel: 'base:z', travelPlus: -400 }, 'b')
-  assert.deepEqual(changed.travel, { source: { of: 'part', part: 'base', axis: 'z' }, plus: -400 })
-  assert.equal(changed.state?.id, 'extend', '같은 조작값 이름')
+  assert.deepEqual(changed.motion![0]!.travel, { source: { of: 'part', part: 'base', axis: 'z' }, plus: -400 })
+  assert.equal(changed.motion![0]!.state?.id, 'extend', '같은 조작값 이름')
 })
 
 test('바닥에 선 부품도 무엇에 붙어 있는지 읽는다 — 그래야 옮겨 붙일 수 있다 (문설주, 2026-09-25)', async () => {
@@ -693,12 +694,51 @@ test('a follower of several leaders and a stroke that is a sum of lengths are wr
   assert.equal(form.follow, '', 'no single leader to pick')
   assert.deepEqual(form.followSum, [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }])
   const saved = motionJoint(wrist, { ...form, axis: form.axis }, 'wrist')
-  assert.deepEqual(saved.mimic, { sum: [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }] }, 'saving the form keeps the follower a follower')
-  assert.equal(saved.state, undefined, 'and gives it no control of its own')
+  assert.deepEqual(saved.motion![0]!.mimic, { sum: [{ motion: 'j2', multiplier: -1 }, { motion: 'j3', multiplier: -1 }] }, 'saving the form keeps the follower a follower')
+  assert.equal(saved.motion![0]!.state, undefined, 'and gives it no control of its own')
   assert.deepEqual(motionOf(asset, 'wrist')?.follows, { sum: [{ joint: 'j2', multiplier: -1 }, { joint: 'j3', multiplier: -1 }], offset: 0 })
 
-  const reach = { ...wrist, id: 'reach', type: 'prismatic' as const, mimic: undefined, axis: 'X' as const, travel: { sum: [{ from: { of: 'part' as const, part: 'base', axis: 'x' as const } }, { from: { of: 'part' as const, part: 'turret', axis: 'x' as const }, times: 0.5 }] } }
+  const reach = { ...wrist, id: 'reach', motion: [{ ...(wrist).motion![0]!, type: 'prismatic' as const, mimic: undefined, axis: 'X' as const, travel: { sum: [{ from: { of: 'part' as const, part: 'base', axis: 'x' as const } }, { from: { of: 'part' as const, part: 'turret', axis: 'x' as const }, times: 0.5 }] } }] }
   const slide = motionFormOf(reach)
   assert.equal(slide.travel, '')
-  assert.deepEqual(motionJoint(reach, slide, 'wrist').travel, reach.travel, 'saving keeps the summed stroke')
+  assert.deepEqual(motionJoint(reach, slide, 'wrist').motion![0]!.travel, reach.motion[0]!.travel, 'saving keeps the summed stroke')
+})
+
+test('어깨는 축 둘 — 축 추가는 쓰지 않은 축으로 시작하고, 고쳐도 다른 축은 그대로, 같은 관절의 다른 축을 따를 수 있고, 축을 빼도 남은 축의 조작값 이름은 그대로 (ADR-0159)', async () => {
+  const { leadersFor, motionJoint, motionFormOf, motionOf, withoutAxis, controlIdFor } = await import('../client/modeller/links.ts')
+  const { compileFigureAsset, motionIdOf } = await import('@hatiolab/figure-model')
+  let asset = createFigureAsset('Shoulder')
+  asset = addFigureBox(asset, { id: 'body', size: { x: 300, y: 400, z: 200 }, position: { x: 0, y: 200, z: 0 } })
+  asset = addFigureBox(asset, { id: 'arm', size: { x: 60, y: 300, z: 60 }, position: { x: 0, y: 550, z: 0 } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'body', to: { plane: 'mounting-plane' } })
+  asset = applyFigureAuthoring(asset, { kind: 'attach', part: 'arm', to: { part: 'body', face: 'top' } })
+  const jointOf = () => asset.joints!.find(j => j.body1.part === 'arm')!
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf(), { ...motionFormOf(jointOf()), kind: 'turn', axis: 'x', id: 'pitch', min: -60, max: 180 }, 'arm') })
+
+  const fresh = motionFormOf(jointOf(), 1)
+  assert.deepEqual([fresh.kind, fresh.axis, fresh.id, fresh.min, fresh.max], ['turn', 'y', '', -90, 90], '새 축은 쓰지 않은 축의 돎')
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf(), fresh, 'arm', 1) })
+  assert.equal(jointOf().motion!.length, 2)
+  assert.equal(controlIdFor('arm', 'turn', 1), 'arm-turn-2')
+  assert.deepEqual(motionOf(asset, 'arm', 1), { kind: 'turn', axis: 'y', control: { id: 'arm-turn-2', unit: 'deg', min: -90, max: 90 } }, '둘째 축은 기록대로 읽는다')
+  assert.equal(motionOf(asset, 'arm')?.control?.id, 'pitch', '첫 축은 그대로')
+
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf(), { ...motionFormOf(jointOf(), 1), min: -30, max: 30 }, 'arm', 1) })
+  assert.deepEqual([jointOf().motion![0]!.lowerLimit, jointOf().motion![0]!.upperLimit, jointOf().motion![1]!.lowerLimit], [-60, 180, -30], '둘째 축만 바뀐다')
+
+  /* The second axis turns the arm about Y, on top of the first. */
+  const turned = (state: Record<string, number>) => compileFigureAsset(asset).evaluate(state).geometry.find(g => g.id === 'arm')!.pose.r
+  assert.notDeepEqual(turned({ 'arm-turn-2': 30 }), turned({}))
+
+  assert.deepEqual(leadersFor(asset, 'arm', 'turn', motionIdOf(jointOf(), 1)).map(a => a.id), ['arm'], '같은 관절의 첫 축은 따를 수 있다')
+  assert.deepEqual(leadersFor(asset, 'arm', 'turn', motionIdOf(jointOf(), 0)).map(a => a.id), ['arm.2'], '제 축은 고르지 않는다')
+
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: motionJoint(jointOf(), { ...motionFormOf(jointOf(), 2), id: 'roll' }, 'arm', 2) })
+  asset = applyFigureAuthoring(asset, { kind: 'set-joint', joint: withoutAxis(jointOf(), 0) })
+  assert.deepEqual(
+    jointOf().motion!.map(a => [a.id, a.state?.id]),
+    [['arm.2', 'arm-turn-2'], ['arm.3', 'roll']],
+    '앞 축을 빼도 뒤 축은 제 이름과 조작값을 지킨다'
+  )
+  assert.notDeepEqual(turned({ 'arm-turn-2': 30 }), turned({}), '남은 축은 같은 조작값으로 움직인다')
 })

package/test/multipart-response-fixture.js

@@ -0,0 +1,17 @@
+import { addFigureBox, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+
+// A relation audit fixture, not a replacement for testing the authoring workflow.
+export function multipartResponseFixture() {
+  let a = addFigureBox(createFigureAsset('부품 관계 점검'), {
+    id: 'tabletop', size: { x: 1500, y: 80, z: 600 }, position: { x: 0, y: 740, z: 0 }
+  })
+  a = applyFigureAuthoring(a, { kind: 'follow-size', part: 'tabletop', axes: ['x'] })
+  a = addFigureBox(a, { id: 'brace', size: { x: 1300, y: 60, z: 40 }, position: { x: 0, y: 0, z: 0 } })
+  a = applyFigureAuthoring(a, { kind: 'link-dimension', part: 'brace', axis: 'x', source: { of: 'part', part: 'tabletop', axis: 'x' }, plus: -200 })
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'brace', to: { part: 'tabletop', face: 'bottom' }, align: { z: 'min' } })
+  for (const [id, x] of [['legLeft', 'min'], ['legRight', 'max']]) {
+    a = addFigureBox(a, { id, size: { x: 80, y: 700, z: 80 }, position: { x: 0, y: 0, z: 0 } })
+    a = applyFigureAuthoring(a, { kind: 'attach', part: id, to: { part: 'tabletop', face: 'bottom' }, align: { x, z: 'max' } })
+  }
+  return a
+}

package/test/multipart-response.test.ts

@@ -0,0 +1,37 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { compileFigureAsset, applyFigureAuthoring, figureFollowOf } from '@hatiolab/figure-model'
+import { multipartResponseFixture } from './multipart-response-fixture.js'
+const part = (a: ReturnType<typeof multipartResponseFixture>, width: number, id: string) =>
+  compileFigureAsset({ ...a, designInputs: { ...a.designInputs, 'size.x': width } }).evaluate().geometry.find(g => g.id === id)!
+
+test('linked brace keeps a 200 mm difference while the tabletop responds to figure width', () => {
+  const a = multipartResponseFixture()
+  assert.deepEqual(figureFollowOf(a, 'brace', 'x'), { of: 'part', part: 'tabletop', axis: 'x', plus: -200 })
+  for (const width of [1500, 2000, 3000]) {
+    assert.equal(part(a, width, 'tabletop').shape.dimensions['size.x'], width)
+    assert.equal(part(a, width, 'brace').shape.dimensions['size.x'], width - 200)
+  }
+})
+
+test('fixed leg dimensions do not imply fixed position: attachment follows the tabletop edge', () => {
+  const a = multipartResponseFixture()
+  for (const id of ['legLeft', 'legRight']) {
+    for (const axis of ['x', 'y', 'z'] as const) assert.equal(figureFollowOf(a, id, axis).of, 'own')
+    assert.deepEqual(part(a, 1500, id).shape, part(a, 3000, id).shape)
+    const sign = id === 'legLeft' ? -1 : 1
+    assert.equal(part(a, 1500, id).pose.t[0], sign * 710)
+    assert.equal(part(a, 3000, id).pose.t[0], sign * 1460)
+    assert.equal(part(a, 3000, id).pose.t[1], 350)
+  }
+})
+
+test('a fixed difference and a proportional relation are not interchangeable', () => {
+  const a = multipartResponseFixture()
+  // Characterize the command currently invoked by the bulk button, not an endorsement of that UI.
+  const proportional = applyFigureAuthoring(a, { kind: 'follow-size', part: 'brace' })
+  assert.equal(figureFollowOf(proportional, 'brace', 'x').of, 'instance')
+  assert.equal(part(a, 3000, 'brace').shape.dimensions['size.x'], 2800)
+  assert.ok(Math.abs(part(proportional, 3000, 'brace').shape.dimensions['size.x']! - 2600) < 0.01)
+  assert.deepEqual(proportional.joints, a.joints, 'attachment remains while dimension reference is replaced')
+})

package/test/refusals.test.ts

@@ -99,9 +99,9 @@ test('지우기는 매단 것 · 따라 움직이는 것을 풀어 남기고 그
   a = act(a, { kind: 'attach', part: 'top', to: { part: 'leg', face: 'top' } })
   a = act(a, { kind: 'attach', part: 'lamp', to: { part: 'top', face: 'top' }, align: { x: { mm: -300 } } })
   a = act(a, { kind: 'attach', part: 'shade', to: { part: 'top', face: 'top' }, align: { x: { mm: 300 } } })
-  const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, type: 'revolute', axis: 'Y', ...extra } })
+  const turn = (asset: typeof a, part: string, extra: object) => act(asset, { kind: 'set-joint', joint: { ...asset.joints!.find(j => j.body1.part === part)!, motion: [{ type: 'revolute', axis: 'Y', ...extra }] } })
   a = turn(a, 'lamp', { state: { id: 'lamp-turn' } })
-  a = turn(a, 'shade', { mimic: { joint: 'lamp', multiplier: 1 } })
+  a = turn(a, 'shade', { mimic: { motion: 'lamp', multiplier: 1 } })
 
   const top = fm.removePart(a, { kind: 'remove-part', target: 'top' })
   const told = removalNoticeOf(top.notice, keyed)!

package/test/resize-with-placement.test.ts

@@ -156,7 +156,7 @@ test('a part fastened at any angle is sized by the gizmo too: its fastening keep
   const { gizmoReachOf } = await import('../client/modeller/gizmo.js')
   let a = addFigureBox(createFigureAsset('UX'), { id: 'hub', size: { x: 200, y: 100, z: 200 }, position: { x: 0, y: 50, z: 0 } })
   a = addFigureBox(a, { id: 'blade', size: { x: 300, y: 20, z: 60 }, position: { x: 0, y: 110, z: 0 } })
-  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'blade', type: 'fixed', body0: { part: 'hub', face: 'top' }, body1: { part: 'blade' }, origin: { childRotate: { z: 30 } } } })
+  a = applyFigureAuthoring(a, { kind: 'set-joint', joint: { id: 'blade', body0: { part: 'hub', face: 'top' }, body1: { part: 'blade' }, origin: { childRotate: { z: 30 } } } })
   assert.ok(gizmoReachOf(a, 'blade').scale, 'offered')
   const size = [{ kind: 'set-design', input: 'blade.size.x', unit: 'mm', value: 400 }] as never
   assert.deepEqual(figureSizeEditOf(a, 'blade', size, { keep: 'opposite', axis: 'x', side: 1 }), { changes: size, kept: 'relation' })
@@ -193,3 +193,25 @@ test('the fastening form keeps a place that follows a position field, and fasten
   assert.ok('box.position.x' in again.designInputs && 'box.position.z' in again.designInputs, 'the fields stay')
   assert.deepEqual(JSON.stringify(again.joints), JSON.stringify(kept.joints), 'the same fastening')
 })
+
+test('fresh frame: width follows without changing height, depth or pose; one undo restores the undeclared figure', async () => {
+  const initial = addFigureBox(createFigureAsset('Frame'), { id: 'frame', size: { x: 1500, y: 80, z: 600 }, position: { x: 0, y: 50, z: 0 } })
+  const source = serializeFigureAsset(initial)
+  const session = createFigureProductSession({ load: async () => ({ id: 'frame', source }), save: async q => ({ id: 'frame', source: q.source }) })
+  await session.open('frame')
+  const before = session.source()
+  session.command({ kind: 'follow-size', part: 'frame', axes: ['x'] })
+  const after = session.source()
+  const asset = parseFigureAsset(after)
+  assert.equal(figureFollowOf(asset, 'frame', 'x').of, 'instance')
+  for (const axis of ['y', 'z'] as const) assert.equal(figureFollowOf(asset, 'frame', axis).of, 'own')
+  const geometry = (a: typeof asset) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === 'frame')!
+  assert.deepEqual(geometry(asset), geometry(initial), 'enabling response preserves the current geometry and pose')
+  const enlarged = geometry({ ...asset, designInputs: { ...asset.designInputs, 'size.x': asset.designInputs['size.x']! * 2, 'size.y': asset.designInputs['size.y']! * 2, 'size.z': asset.designInputs['size.z']! * 2 } })
+  const expected = geometry(addFigureBox(createFigureAsset('Frame'), { id: 'frame', size: { x: 3000, y: 80, z: 600 }, position: { x: 0, y: 50, z: 0 } }))
+  assert.deepEqual(enlarged, expected, 'only width doubles even when every figure dimension doubles')
+  session.undo()
+  assert.equal(session.source(), before, 'one undo also removes the automatically declared figure size')
+  session.redo()
+  assert.equal(session.source(), after)
+})

package/test/size-response.test.ts

@@ -0,0 +1,49 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { applyFigureAuthoring, compileFigureAsset, figureRowOf, figureFollowOf } from '@hatiolab/figure-model'
+import { sizeRelationSteps, sizeRelationOf, sizeInputOf } from '../client/modeller/size-response.ts'
+import type { FigureRevision } from '../client/modeller/revision.ts'
+import { multipartResponseFixture } from './multipart-response-fixture.js'
+const revision = (asset: ReturnType<typeof multipartResponseFixture>) => ({ asset, inputs: asset.designInputs } as FigureRevision)
+const width = (a: ReturnType<typeof multipartResponseFixture>, id: string) => compileFigureAsset(a).evaluate().geometry.find(g => g.id === id)!.shape.dimensions['size.x']
+
+test('switching difference to ratio preserves current size, changes future response, and leaves attachment intact', () => {
+ const a = multipartResponseFixture()
+ assert.equal(sizeRelationOf(revision(a), 'brace', 'x').mode, 'difference')
+ const b = sizeRelationSteps(revision(a), 'brace', 'x', {of:'part',part:'tabletop',axis:'x'}, 'ratio').reduce(applyFigureAuthoring, a)
+ assert.equal(width(b,'brace'),1300)
+ assert.deepEqual(b.joints,a.joints)
+ assert.equal(sizeRelationOf(revision(b),'brace','x').mode,'ratio')
+ assert.equal(width({...b,designInputs:{...b.designInputs,'size.x':3000}},'brace'),2600)
+})
+test('own X can keep a difference from another part Y; switching source preserves its current size', () => {
+ const a = multipartResponseFixture()
+ const b = sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'tabletop',axis:'y'},'difference').reduce(applyFigureAuthoring,a)
+ assert.equal(width(b,'brace'),1300)
+ assert.deepEqual(figureFollowOf(b,'brace','x'),{of:'part',part:'tabletop',axis:'y',plus:1220})
+ assert.deepEqual(b.joints,a.joints)
+})
+test('editing a linked size updates its difference without changing the reference', () => {
+ const a=multipartResponseFixture()
+ const b=sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'tabletop',axis:'x'},'difference',1250.25).reduce(applyFigureAuthoring,a)
+ assert.equal(width(b,'brace'),1250.25)
+ assert.equal(width({...b,designInputs:{...b.designInputs,'size.x':3000}},'brace'),2750.25)
+ assert.equal(sizeInputOf(a,'brace','x'),undefined)
+ assert.ok(sizeInputOf(a,'legLeft','x'))
+ assert.throws(()=>sizeRelationSteps(revision(a),'brace','x',{of:'part',part:'brace',axis:'x'},'ratio'),/SIZE_SOURCE/)
+})
+
+test('repeat settings can change count, direction and mode without losing the attachment or size relation', () => {
+ let a=applyFigureAuthoring(multipartResponseFixture(), {kind:'make-repeat',part:'legLeft',axis:'x',pitch:200})
+ const initial=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...initial,repeat:{...initial.repeat!,count:5}}})
+ assert.equal(figureRowOf(a,'legLeft')!.count,5)
+ const current=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...current,repeat:{...current.repeat!,axis:'Z',count:3}}})
+ assert.equal(figureRowOf(a,'legLeft')!.count,3)
+ const last=a.joints!.find(j=>j.body1.part==='legLeft')!
+ a=applyFigureAuthoring(a,{kind:'set-joint',joint:{...last,repeat:{...last.repeat!,count:undefined,pitch:200}}})
+ assert.equal(a.joints!.find(j=>j.body1.part==='legLeft')!.repeat!.count,undefined)
+ assert.deepEqual(a.joints!.find(j=>j.body1.part==='legLeft')!.body0,initial.body0)
+ assert.deepEqual(figureFollowOf(a,'brace','x'),{of:'part',part:'tabletop',axis:'x',plus:-200})
+})

package/test/size-source-pairing.test.ts

@@ -0,0 +1,66 @@
+/*
+ * What a size follows when it is made to follow (ADR-0159 3): what its part hangs from, along the axis its own lies
+ * on as it stands -- read from figure-model (`figureAxisPairsOf`), never paired by letter.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { addFigureBox, addFigurePrimitive, applyFigureAuthoring, createFigureAsset } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureAuthoringAction } from '@hatiolab/figure-model'
+
+import { revisionOf } from './revision-of.ts'
+import { sameSizeSource, sizeRelationOf, sizeRelationSteps, sourceMeasureOf, suggestedSizeSource } from '../client/modeller/size-response.ts'
+import { measureNow } from '../client/modeller/links.ts'
+
+/** A frame on the floor, 1000 wide, 100 high, 600 deep, and a roller on its top turned `turn` about X. */
+function bed(turn = 90): FigureAsset {
+  let a = addFigureBox(createFigureAsset('Bed'), { id: 'frame', size: { x: 1000, y: 100, z: 600 }, position: { x: 0, y: 50, z: 0 } })
+  a = addFigurePrimitive(a, { id: 'roller', kind: 'cylinder', dimensions: { radius: 30, length: 500 }, rotation: { x: turn, y: 0, z: 0 }, position: { x: 0, y: 150, z: 0 } } as never)
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'frame', to: { plane: 'mounting-plane' } })
+  return applyFigureAuthoring(a, { kind: 'attach', part: 'roller', to: { part: 'frame', face: 'top' } })
+}
+const run = (a: FigureAsset, steps: FigureAuthoringAction[]) => steps.reduce((x, s) => applyFigureAuthoring(x, s), a)
+const lengthOf = (a: FigureAsset, design: Record<string, number> = {}) =>
+  measureNow(revisionOf({ ...a, designInputs: { ...a.designInputs, ...design } }), 'roller', 'y')
+/** The frame's depth: its own size along Z. */
+const depthOf = (_: FigureAsset) => 'frame.size.z'
+
+test('a roller laid on its side follows the frame\'s depth with its length, not its height', () => {
+  assert.deepEqual(suggestedSizeSource(bed(), 'roller', 'y'), { of: 'part', part: 'frame', axis: 'z' })
+  /* Its diameter lies along the frame's width. */
+  assert.deepEqual(suggestedSizeSource(bed(), 'roller', 'x'), { of: 'part', part: 'frame', axis: 'x' })
+})
+
+test('made to follow by its gap, the length keeps 100 mm short of the frame\'s depth as the frame grows', () => {
+  const a = bed()
+  const b = run(a, sizeRelationSteps(revisionOf(a), 'roller', 'y', suggestedSizeSource(a, 'roller', 'y')!, 'difference'))
+  assert.equal(lengthOf(b), 500, 'it stands as it stood')
+  assert.ok(depthOf(b) in b.designInputs, `the frame's depth is an input: ${Object.keys(b.designInputs)}`)
+  assert.equal(lengthOf(b, { [depthOf(b)]: 900 }), 800, 'the frame 300 deeper: the roller 300 longer')
+  assert.equal(sizeRelationOf(revisionOf(b), 'roller', 'y').mode, 'difference')
+})
+
+test('made to follow by its ratio, it keeps its share', () => {
+  const a = bed()
+  const b = run(a, sizeRelationSteps(revisionOf(a), 'roller', 'y', suggestedSizeSource(a, 'roller', 'y')!, 'ratio'))
+  assert.equal(Math.round(lengthOf(b, { [depthOf(b)]: 1200 })!), 1000, '500 of 600 is 1000 of 1200')
+})
+
+test('standing on the floor turned a quarter, a part follows the figure along the axis it lies on', () => {
+  let a = addFigureBox(createFigureAsset('Beam'), { id: 'beam', size: { x: 100, y: 50, z: 800 }, position: { x: 0, y: 25, z: 0 }, rotation: { x: 0, y: 90, z: 0 } } as never)
+  a = applyFigureAuthoring(a, { kind: 'attach', part: 'beam', to: { plane: 'mounting-plane' } })
+  assert.deepEqual(suggestedSizeSource(a, 'beam', 'z'), { of: 'instance', axis: 'x' })
+})
+
+test('at an angle, nothing is suggested for the axes that lie at it: the author picks', () => {
+  assert.equal(suggestedSizeSource(bed(30), 'roller', 'y'), undefined)
+  assert.deepEqual(suggestedSizeSource(bed(30), 'roller', 'x'), { of: 'part', part: 'frame', axis: 'x' }, 'the axis it turns about still lies along X')
+})
+
+test('the source as it measures now, and when two sources are one', () => {
+  const r = revisionOf(bed())
+  assert.equal(sourceMeasureOf(r, { of: 'part', part: 'frame', axis: 'z' }), 600)
+  assert.ok(sameSizeSource({ of: 'part', part: 'frame', axis: 'z' }, { of: 'part', part: 'frame', axis: 'z' }))
+  assert.ok(!sameSizeSource({ of: 'part', part: 'frame', axis: 'z' }, { of: 'part', part: 'frame', axis: 'y' }))
+  assert.ok(!sameSizeSource({ of: 'instance', axis: 'z' }, { of: 'part', part: 'frame', axis: 'z' }))
+  assert.ok(!sameSizeSource(undefined, { of: 'instance', axis: 'z' }))
+})

package/translations/en.json

@@ -52,9 +52,9 @@
   "figure.text.scale-position-explained": "keeps this place as a share of the figure size — at twice the size it is twice as far.",
   "figure.text.repeat-member": "copy {index} of {count} made by repeating {name}.",
   "figure.label.detail-none": "none",
-  "figure.label.repeat": "arranged in a row",
-  "figure.text.repeat-fits-length": "as many copies as fit the figure’s length at this pitch.",
-  "figure.text.repeat-fixed-count": "a repeat of a fixed count; its pitch cannot be set yet.",
+  "figure.label.repeat": "Repeat layout",
+  "figure.text.repeat-fits-length": "Parts fill the parent length at the chosen centre spacing.",
+  "figure.text.repeat-fixed-count": "Centre spacing is calculated automatically to keep the count.",
   "figure.text.repeat-what-pitch-gives": "{count} at a length of {length} mm · placed up to {longest} mm long ({limit} in a row).",
   "figure.text.repeat-pitch-too-small": "the pitch must be at least {min} mm: at the authored length of {length} mm it would make more than {limit}.",
   "figure.text.row-copies-over-limit": "At this pitch the row has {count} copies. A row takes up to {limit}. Widen the pitch.",
@@ -76,6 +76,7 @@
   "figure.text.gizmo-joint-turned-slide": "the {joint} joint only slides. use the move handle.",
   "figure.text.gizmo-joint-origin-follows": "the {joint} joint's place follows another part. change it under place in the properties tab.",
   "figure.text.gizmo-joint-off-axis": "the {joint} joint turns only about {axis}. use the {axis} rotate handle.",
+  "figure.text.gizmo-joint-several-axes": "the {joint} joint moves on several axes, so it cannot be dragged. adjust its values on the motion tab.",
   "figure.text.gizmo-size-follows": "{part}'s {axis} size follows another measure. change it under size in the responsive tab.",
   "figure.text.gizmo-fastening-places": "{part} is fastened to a face of another part, which places it. detach it first to move it.",
   "figure.text.size-range-leaves-out-size": "the {axis} range on a drawing, {range} mm, does not hold its size now, {at} mm.",
@@ -593,6 +594,9 @@
   "figure.label.control-start": "start",
   "figure.label.travel-follows": "travel follows",
   "figure.button.add-motion": "Add motion",
+  "figure.button.add-axis": "Add axis",
+  "figure.button.remove-axis": "Remove axis",
+  "figure.label.motion-axis-n": "Axis {n}",
   "figure.button.remove-motion": "Remove motion",
   "figure.label.room": "Room it takes up",
   "figure.text.room-explained": "Bounds computed from the parts are a proposal. Nothing is declared until you confirm, and a declaration never widens on its own.",
@@ -697,12 +701,12 @@
   "figure.label.face-opening-left": "opening left",
   "figure.label.face-opening-right": "opening right",
   "figure.label.face-opening-top": "opening top",
-  "figure.label.repeat-fills": "as many as fill the length (set the pitch)",
-  "figure.button.make-repeat": "arrange in a row",
-  "figure.button.remove-repeat": "remove the row",
-  "figure.label.row-basis": "how many",
-  "figure.label.row-by-count": "a set count",
-  "figure.text.row-count-spreads": "A set count is spread evenly over the length. Check the spacing in the preview.",
+  "figure.label.repeat-fills": "Keep spacing",
+  "figure.button.make-repeat": "Apply repeat layout",
+  "figure.button.remove-repeat": "Remove repeat layout",
+  "figure.label.row-basis": "Layout rule",
+  "figure.label.row-by-count": "Keep count",
+  "figure.text.row-count-spreads": "Distribute the chosen count evenly along the parent length. Centre spacing is calculated automatically.",
   "figure.text.row-blocked-unfastened": "Fasten {part} to another part to arrange it in a row along that part.",
   "figure.text.row-blocked-on-plane": "Fasten it to another part, not the mounting plane, to arrange it in a row along that part.",
   "figure.text.row-blocked-at-origin": "It stands at another part's origin. Fasten it to a face of that part to arrange it in a row along it.",
@@ -1184,5 +1188,38 @@
   "figure.text.board-size-range-explained": "A drawing can resize it within these ranges. An empty field is as far as the parts allow; a number typed narrows it to that. Only the parts that follow its size grow with it; the rest stay as they are.",
   "figure.text.board-size-followers": "parts that change with its size: {parts}",
   "figure.text.board-size-followers-more": "{first} and {rest} more",
-  "figure.text.board-size-no-followers": "no part changes with its size"
+  "figure.text.board-size-no-followers": "no part changes with its size",
+  "figure.button.resize-follow": "Scale proportionally",
+  "figure.button.resize-follow-axis": "Scale {dimension} proportionally",
+  "figure.text.resize-follow-axis": "Follow the figure size at the current proportion. Other dimensions stay unchanged.",
+  "figure.label.size-axis": "axis",
+  "figure.label.size-measure": "size (mm)",
+  "figure.label.size-follows": "follows",
+  "figure.label.size-source": "source",
+  "figure.label.size-source-axis": "source axis",
+  "figure.label.size-diameter": "diameter",
+  "figure.label.size-figure": "figure",
+  "figure.label.size-ratio": "keep the ratio",
+  "figure.label.size-difference": "keep the gap",
+  "figure.label.size-existing-rule": "existing formula",
+  "figure.label.size-pick-source": "pick a source",
+  "figure.button.size-other-source": "another source",
+  "figure.text.size-ratio-result": "{pct}% of {source} {size} mm — changes by the same ratio when the source does.",
+  "figure.text.size-difference-less": "{gap} mm less than {source} {size} mm — keeps that gap when the source changes.",
+  "figure.text.size-difference-more": "{gap} mm more than {source} {size} mm — keeps that gap when the source changes.",
+  "figure.text.size-difference-same": "the same as {source} {size} mm — changes as the source does.",
+  "figure.text.size-custom-rule": "set by an existing formula. pick a source or a way and it changes from the size it is now.",
+  "figure.text.size-uniform": "the whole figure grows and shrinks by one ratio.",
+  "figure.text.size-invalid": "enter a size above 0.",
+  "figure.text.size-unavailable-source": "this source's size cannot be followed.",
+  "figure.text.size-unpaired": "it lies at an angle, so the axis to follow cannot be told. pick a source and an axis.",
+  "figure.label.repeat-inactive": "Not applied",
+  "figure.label.repeat-active": "Applied",
+  "figure.label.tab-arrangement": "Layout",
+  "figure.text.repeat-intro": "Repeat this part along the length of the part it is attached to.",
+  "figure.text.repeat-direction": "Direction uses the attached parent’s axes.",
+  "figure.text.repeat-draft": "Preview only. Apply to confirm this layout.",
+  "figure.text.repeat-mode-pitch": "Keep spacing · Count changes with the parent length.",
+  "figure.text.repeat-mode-count": "Keep count · Spacing changes with the parent length.",
+  "figure.text.repeat-remove-explained": "Removing the layout leaves the original part."
 }

package/translations/es.json

@@ -52,9 +52,9 @@
   "figure.text.scale-position-explained": "mantiene esta posición como fracción del tamaño de la figura: con el doble de tamaño queda al doble de distancia.",
   "figure.text.repeat-member": "copia {index} de {count} creada al repetir {name}.",
   "figure.label.detail-none": "ninguno",
-  "figure.label.repeat": "dispuestas en fila",
-  "figure.text.repeat-fits-length": "tantas copias como quepan en la longitud de la figura con este pitch.",
-  "figure.text.repeat-fixed-count": "una repetición de cantidad fija; su pitch aún no se puede definir.",
+  "figure.label.repeat": "Distribución repetida",
+  "figure.text.repeat-fits-length": "Las piezas ocupan la longitud de referencia con la separación elegida.",
+  "figure.text.repeat-fixed-count": "La separación se calcula para mantener la cantidad.",
   "figure.text.repeat-what-pitch-gives": "{count} con una longitud de {length} mm · se colocan hasta {longest} mm de longitud ({limit} en una fila).",
   "figure.text.repeat-pitch-too-small": "el pitch debe ser de al menos {min} mm: con la longitud definida de {length} mm se superarían {limit}.",
   "figure.text.row-copies-over-limit": "Con este paso la fila tiene {count} copias. Una fila admite hasta {limit}. Amplíe el paso.",
@@ -76,6 +76,7 @@
   "figure.text.gizmo-joint-turned-slide": "la articulación {joint} solo se desliza. use el control de desplazamiento.",
   "figure.text.gizmo-joint-origin-follows": "la posición de la articulación {joint} sigue a otra pieza. cámbiela en sujeción, en la pestaña de movimiento.",
   "figure.text.gizmo-joint-off-axis": "la articulación {joint} solo gira alrededor de {axis}. use el control de rotación de {axis}.",
+  "figure.text.gizmo-joint-several-axes": "la articulación {joint} se mueve en varios ejes, así que no se puede arrastrar. ajuste sus valores en la pestaña de movimiento.",
   "figure.text.gizmo-size-follows": "el tamaño en {axis} de {part} sigue a otra medida. cámbielo en tamaños, en la pestaña de movimiento.",
   "figure.text.gizmo-fastening-places": "{part} está sujeta a una cara de otra pieza, que determina su posición. sepárela primero para moverla.",
   "figure.text.size-range-leaves-out-size": "el rango {axis} en un plano, {range} mm, no incluye su tamaño actual, {at} mm.",
@@ -593,6 +594,9 @@
   "figure.label.control-start": "inicio",
   "figure.label.travel-follows": "el recorrido sigue a",
   "figure.button.add-motion": "Añadir movimiento",
+  "figure.button.add-axis": "Añadir eje",
+  "figure.button.remove-axis": "Quitar eje",
+  "figure.label.motion-axis-n": "Eje {n}",
   "figure.button.remove-motion": "Quitar movimiento",
   "figure.label.room": "Espacio que ocupa",
   "figure.text.room-explained": "Los límites calculados a partir de las piezas son una propuesta. No se declara nada hasta que lo confirme, y una declaración nunca se amplía por sí sola.",
@@ -697,12 +701,12 @@
   "figure.label.face-opening-left": "abertura izquierda",
   "figure.label.face-opening-right": "abertura derecha",
   "figure.label.face-opening-top": "abertura superior",
-  "figure.label.repeat-fills": "tantas como llenen la longitud (definir el pitch)",
-  "figure.button.make-repeat": "disponer en fila",
-  "figure.button.remove-repeat": "quitar la fila",
-  "figure.label.row-basis": "cuántas",
-  "figure.label.row-by-count": "una cantidad fija",
-  "figure.text.row-count-spreads": "Una cantidad fija se reparte uniformemente a lo largo de la longitud. Compruebe la separación en la vista previa.",
+  "figure.label.repeat-fills": "Mantener separación",
+  "figure.button.make-repeat": "Aplicar distribución",
+  "figure.button.remove-repeat": "Quitar distribución",
+  "figure.label.row-basis": "Regla de distribución",
+  "figure.label.row-by-count": "Mantener cantidad",
+  "figure.text.row-count-spreads": "Distribuya la cantidad elegida uniformemente. La separación se calcula automáticamente.",
   "figure.text.row-blocked-unfastened": "Sujete {part} a otra pieza para disponerla en fila a lo largo de esa pieza.",
   "figure.text.row-blocked-on-plane": "Sujétela a otra pieza, no al plano de montaje, para disponerla en fila a lo largo de esa pieza.",
   "figure.text.row-blocked-at-origin": "Está en el origen de otra pieza. Sujétela a una cara de esa pieza para disponerla en fila a lo largo de ella.",
@@ -1184,5 +1188,38 @@
   "figure.text.board-size-range-explained": "Un plano puede cambiar su tamaño dentro de estos rangos. Un campo vacío llega hasta donde permiten las piezas; un número lo limita a ese valor. Solo crecen las piezas que siguen su tamaño; las demás quedan igual.",
   "figure.text.board-size-followers": "piezas que cambian con su tamaño: {parts}",
   "figure.text.board-size-followers-more": "{first} y {rest} más",
-  "figure.text.board-size-no-followers": "ninguna pieza cambia con su tamaño"
+  "figure.text.board-size-no-followers": "ninguna pieza cambia con su tamaño",
+  "figure.button.resize-follow": "Cambiar proporcionalmente",
+  "figure.button.resize-follow-axis": "Cambiar {dimension} proporcionalmente",
+  "figure.text.resize-follow-axis": "Seguir el tamaño de la figura manteniendo la proporción actual. Las otras dimensiones no cambian.",
+  "figure.label.size-axis": "eje",
+  "figure.label.size-measure": "tamaño (mm)",
+  "figure.label.size-follows": "sigue",
+  "figure.label.size-source": "referencia",
+  "figure.label.size-source-axis": "eje de referencia",
+  "figure.label.size-diameter": "diámetro",
+  "figure.label.size-figure": "figura",
+  "figure.label.size-ratio": "mantener la proporción",
+  "figure.label.size-difference": "mantener la holgura",
+  "figure.label.size-existing-rule": "fórmula existente",
+  "figure.label.size-pick-source": "elija una referencia",
+  "figure.button.size-other-source": "otra referencia",
+  "figure.text.size-ratio-result": "{pct}% de {source} {size} mm — cambia en la misma proporción cuando cambia la referencia.",
+  "figure.text.size-difference-less": "{gap} mm menos que {source} {size} mm — mantiene esa diferencia cuando cambia la referencia.",
+  "figure.text.size-difference-more": "{gap} mm más que {source} {size} mm — mantiene esa diferencia cuando cambia la referencia.",
+  "figure.text.size-difference-same": "igual que {source} {size} mm — cambia como la referencia.",
+  "figure.text.size-custom-rule": "lo fija una fórmula existente. elija una referencia o un modo y cambiará a partir del tamaño actual.",
+  "figure.text.size-uniform": "toda la figura crece y se reduce en una sola proporción.",
+  "figure.text.size-invalid": "introduzca un tamaño mayor que 0.",
+  "figure.text.size-unavailable-source": "no se puede seguir el tamaño de esta referencia.",
+  "figure.text.size-unpaired": "está en ángulo, así que no se sabe qué eje seguir. elija una referencia y un eje.",
+  "figure.label.repeat-inactive": "Sin aplicar",
+  "figure.label.repeat-active": "Aplicada",
+  "figure.label.tab-arrangement": "Distribución",
+  "figure.text.repeat-intro": "Repita esta pieza a lo largo de la pieza a la que está unida.",
+  "figure.text.repeat-direction": "La dirección usa los ejes de la pieza de unión.",
+  "figure.text.repeat-draft": "Vista previa. Pulse Aplicar para confirmar.",
+  "figure.text.repeat-mode-pitch": "Mantener separación · La cantidad cambia con la longitud de referencia.",
+  "figure.text.repeat-mode-count": "Mantener cantidad · La separación cambia con la longitud de referencia.",
+  "figure.text.repeat-remove-explained": "Al quitar la distribución queda la pieza original."
 }