@things-factory/figure-ui 10.1.203 → 10.1.205

package/client/modeller/size-drag.ts

@@ -0,0 +1,112 @@
+import { compileFigureDocument, figurePlacementOf, figureShapeReachOf, figureSizeEditOf, figureSizeEditorOf } from '@hatiolab/figure-model'
+import type { FigureAsset, FigureInputChange, FigureSizeKeep } from '@hatiolab/figure-model'
+
+import { ownerOf } from './fields.js'
+import type { FigureRenderPart } from './renderer.js'
+
+/*
+ * A size drag drawn from figure-model, frame by frame (ADR-0140 4.4). The gizmo says only which handle and how far; the
+ * one size function (`figureSizeEditorOf`) turns the sizes into the changes a commit writes, and the instance evaluator
+ * the figure is compiled into once, when the drag begins, steps to them (`advance`). What is drawn while dragging is
+ * what the release writes: the same function, the same sizes, the same keep. Nothing drawn goes back into what the
+ * gizmo computes (2026-09-24: the gizmo fought the modeller when evaluations were written back onto it).
+ */
+
+export interface SizeDragFrame {
+  /** What a release now would write: the sizes and, for a free part, its own position. */
+  changes: FigureInputChange[]
+  /**
+   * Every body moved or reshaped since the drag began, by id: its pose and shape at this frame as figure-model evaluates
+   * them. The evaluator tells only what changed since the frame before; a body that moved and then stood still is kept.
+   */
+  moved: Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>
+}
+
+export interface SizeDrag {
+  part: string
+  keep: FigureSizeKeep
+  frame(sizes: readonly FigureInputChange[]): SizeDragFrame
+}
+
+type Pose = FigureRenderPart['pose']
+
+/** The drag of `part`'s size from `inputs` (the figure's inputs as it is drawn), keeping what `keep` says. */
+export function startSizeDrag(asset: FigureAsset, part: string, inputs: Record<string, number>, keep: FigureSizeKeep): SizeDrag {
+  const edit = figureSizeEditorOf(asset, part)
+  const evaluator = compileFigureDocument(asset.document).evaluator({ changes: true })
+  const base = { ...asset.designInputs, ...asset.stateDefaults, ...inputs }
+  /* The bodies as the evaluator numbers its slots: the order of this first evaluation. */
+  let ids = evaluator.evaluate(base).geometry.map(g => (g as { id: string }).id)
+  const moved = new Map<string, Pick<FigureRenderPart, 'pose' | 'shape'>>()
+  return {
+    part,
+    keep,
+    frame(sizes) {
+      const { changes } = edit(sizes, keep)
+      const next = { ...base }
+      for (const c of changes) next[c.input] = c.value as number
+      const step = evaluator.advance(next)
+      if (step.kind === 'changes' && step.structure) ids = step.structure.ids
+      for (let k = 0; k < step.bodies.length; k++) {
+        const id = ids[step.bodies[k]!]
+        const p = step.poses.subarray(k * 12, k * 12 + 12)
+        if (id === undefined || Number.isNaN(p[0]!)) continue
+        const pose: Pose = { r: [[p[0]!, p[1]!, p[2]!], [p[3]!, p[4]!, p[5]!], [p[6]!, p[7]!, p[8]!]], t: [p[9]!, p[10]!, p[11]!] }
+        /* The evaluator's shapes are frozen; the scene's builder writes into what it is given, so the canvas gets its own copy. */
+        const frozen = step.kind === 'changes' ? step.shapes[k] : undefined
+        const shape = frozen ? structuredClone(frozen) : undefined
+        const had = moved.get(id)
+        moved.set(id, { pose, ...(shape ? { shape: shape as unknown as FigureRenderPart['shape'] } : had?.shape ? { shape: had.shape } : {}) } as Pick<FigureRenderPart, 'pose' | 'shape'>)
+      }
+      return { changes, moved: new Map(moved) }
+    }
+  }
+}
+
+/**
+ * What a size typed for this part keeps, in figure-model's words: its middle (`centre`), its fastening (`relation`), or
+ * no point -- its position is worked out, and only the size changes (`none`). The words beside the size fields (ADR-0140
+ * 4.1, chief architect 10-20); nothing when the part cannot be asked.
+ */
+export function keptBySizeOf(asset: FigureAsset, part: string): 'centre' | 'relation' | 'none' | undefined {
+  try {
+    const kept = figureSizeEditOf(asset, part, [], { keep: 'centre' }).kept
+    return kept === 'opposite' ? undefined : kept
+  } catch {
+    return undefined
+  }
+}
+
+/** The words for what a size keeps, by `keptBySizeOf`'s answer. */
+export const SIZE_KEEPS_WORDS = { centre: 'figure.text.size-keeps-centre', relation: 'figure.text.size-keeps-fastening', none: 'figure.text.size-keeps-none' } as const
+
+/** The parts drawn this frame: each one the frame moved, with its new pose and shape; every other one as it was. */
+export function partsAtFrame(parts: readonly FigureRenderPart[], moved: SizeDragFrame['moved']): FigureRenderPart[] {
+  if (!moved.size) return parts as FigureRenderPart[]
+  return parts.map(part => {
+    const now = moved.get(part.id)
+    return now ? { ...part, pose: now.pose, ...(now.shape ? { shape: now.shape } : {}) } : part
+  })
+}
+
+/** The side of its mounting plane a figure uses (ADR-0097 4.2): up from a floor, down from a ceiling, out of a wall. */
+const USED: Record<string, [number, number, number] | undefined> = { floor: [0, 1, 0], ceiling: [0, -1, 0], wall: [0, 0, 1], center: undefined }
+
+/**
+ * How far a free part goes past its figure's mounting plane, in millimetres, as drawn: its real shape's extreme against
+ * the side the placement uses (figure-model's reach, the rule a fastening stands a part by). 0 when it does not, for a
+ * fastened part -- its fastening places it -- and for a figure placed by its centre (ADR-0140 5).
+ */
+export function throughPlaneOf(asset: FigureAsset, parts: readonly FigureRenderPart[], part: string): number {
+  const n = USED[figurePlacementOf(asset)]
+  if (!n || (asset.joints ?? []).some(j => j.body1.part === part)) return 0
+  let lowest = Infinity
+  for (const body of parts) {
+    if (ownerOf(body.id) !== part) continue
+    const { r, t } = body.pose
+    /* The side's direction in the body's own frame: rᵀ n. */
+    const d = [0, 1, 2].map(j => r[0]![j]! * n[0] + r[1]![j]! * n[1] + r[2]![j]! * n[2]) as [number, number, number]
+    lowest = Math.min(lowest, t[0]! * n[0] + t[1]! * n[1] + t[2]! * n[2] + figureShapeReachOf(body.shape as never, d).min)
+  }
+  return Number.isFinite(lowest) && lowest < 0 ? Math.round(-lowest * 10) / 10 : 0
+}

package/client/modeller/slot-layout-host.ts

@@ -66,14 +66,14 @@ export function anchorFacesOf(anchors: readonly SlotAnchor[], geometry: readonly
  * a one-anchor preset on the first, a twin fork on the first two. A single slot stands on a top and hangs from a bottom.
  * The editor's own controls then make it what the equipment is.
  */
-export function slotPresetsOf(anchors: readonly SlotAnchor[], say: (key: string) => string) {
+export function slotPresetsOf(anchors: readonly SlotAnchor[]) {
   const first = anchors[0]
   const on = { ...(first ? { anchor: first.id } : {}), ...(anchors.length >= 2 ? { forks: [anchors[0]!.id, anchors[1]!.id] as [string, string] } : {}) }
   const mount = first?.face === 'bottom' ? ('HANG' as const) : ('ON' as const)
   return SLOT_LAYOUT_PRESET_KEYS.map(key => ({
     key,
-    label: say(`figure.label.slot-preset-${key}`),
-    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, label: say(`figure.label.slot-preset-param-${p.key}`), integer: p.integer })),
+    /* The editor names a preset and its values from their keys (@operato/slot-layout-editor's own words). */
+    params: SLOT_LAYOUT_PRESET_PARAMS[key].map(p => ({ key: p.key, integer: p.integer })),
     build: (size: SlotPresetSize, params: Record<string, number>) => slotLayoutPreset(key, size, params, { ...on, mount })
   }))
 }

package/client/modeller/stage-model.ts

@@ -64,16 +64,13 @@ function colours(part: FigureRenderPart, palette: Record<string, string>) {
   return { color: palette[m.token] ?? '#9a9a9a', preset: m.preset, transparent: !!m.transparent, ...(glow ? { glow } : {}) }
 }
 
-/** Per axis of the body's own frame, the face a size drag keeps: 1 the low face, -1 the high face, 0 the centre. */
-export type ScaleAnchor = Record<'x' | 'y' | 'z', -1 | 0 | 1>
-
 /**
- * The component state that draws a body where figure-model put it. With `anchor` -- figure-model's
- * `figureScaleAnchorOf` for its part -- the scene's scale gizmo keeps that face while it is dragged, the face the model
- * keeps when the drag is written; without it the gizmo keeps the face across from the handle held, and the part jumped
- * on release (designer 2026-09-27). Body x · y · z are the component's width · depth · height, as the scene's axes are.
+ * The component state that draws a body where figure-model put it. A part the author edits is `owned`: while its size
+ * is dragged the scene does not move it and tells the handle held (`scaleGrab`), and the modeller draws where
+ * figure-model's size function puts it, every frame (ADR-0140 4.4). Body x · y · z are the component's width · depth ·
+ * height, as the scene's axes are.
  */
-export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, anchor?: ScaleAnchor): Record<string, unknown> | null {
+export function componentOf(part: FigureRenderPart, palette: Record<string, string>, board: Board, owned = false): Record<string, unknown> | null {
   const frame = frameOf(part)
   if (!frame) return null
   const { centre, extent, rotation, origin } = frame
@@ -97,7 +94,7 @@ export function componentOf(part: FigureRenderPart, palette: Record<string, stri
     rotationX: round(euler.x),
     rotation: round(-euler.y),
     rotationY: round(euler.z),
-    ...(anchor ? { scaleAnchor: { ...anchor } } : {})
+    ...(owned ? { scalePlacement: 'owner' } : {})
   }
 }
 

package/client/pages/figure-modeller-page.ts

@@ -147,8 +147,6 @@ export class FigureModellerPage extends PageView {
   @state() private commandError = ''
   /** What the verdict says blocks release now, handed to the editor's bar. */
   @state() private releaseBlockers: FigureGateFinding[] = []
-  /** The verdict's count, handed to the editor's verdict tab. */
-  @state() private instances?: number
   @state() private budget?: FigureBudgetLine
   private wasDirty = false
   private titled?: string | null
@@ -532,7 +530,7 @@ export class FigureModellerPage extends PageView {
     if (this.error) return html`<p role="alert" class="error">${this.error}</p>`
     const view = this.session.read()
     /* A new figure's third way to start: the app's assistant dock, with a request put in its input for the author to finish and send (B, U04). */
-    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .instances=${this.instances} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
+    return html`<figure-editor .session=${this.session} .releaseState=${this.row} .releaseBlockers=${this.releaseBlockers} .templates=${this.templates} .guideOf=${this.guideOf} .thumbnailOf=${this.thumbnailOf} .firstSave=${this.askFirstSave} .revision=${this.revision} .budget=${this.budget} aiDraft @ask-ai-draft=${() => askAssistant({ draft: i18next.t('figure.text.ai-draft-request') })} @changed=${this.changed}>
       ${this.commandError ? html`<p slot="notice" fit-error role="alert">${this.commandError}</p>` : ''}
       <figure-properties
         slot="figure"
@@ -562,7 +560,6 @@ export class FigureModellerPage extends PageView {
         .figureId=${view.id}
         .figureType=${this.row.type}
         @capacity-changed=${(event: CustomEvent) => {
-          this.instances = event.detail.instances
           this.budget = event.detail.budget
         }}
         @fit-base-to-parts=${this.fitToParts}

package/dist-client/modeller/canvas.d.ts

@@ -2,16 +2,19 @@ import { LitElement, type PropertyValues } from 'lit';
 import type { GizmoReach } from './gizmo.js';
 import type { FigureRenderPart } from './renderer.js';
 import { type ViewSettings } from '@things-factory/figure-viewer/dist-client/figure-view.js';
-import { type ScaleAnchor } from './stage-model.js';
 export declare class FigureCanvas extends LitElement {
     static styles: import("lit").CSSResult;
     parts: FigureRenderPart[];
     palette: Record<string, string>;
-    /** The face a size drag keeps, per part (figure-model's `figureScaleAnchorOf`), so the drag shows what is written. */
-    anchors: Record<string, ScaleAnchor>;
     /** Which figure is open. Another one stands the board up again. */
     context: string;
     selected: string;
+    /**
+     * The fastening window is open (ADR-0140 stage 4): a part pressed is aimed at, not chosen -- told out as `part-aimed`
+     * with where the press landed (the scene's `pickedAt`: the point and the drawn triangle's outward normal, in the
+     * figure's frame), and the part being fastened stays chosen.
+     */
+    aiming: boolean;
     /** What the gizmo may write for the selected part; a change beyond it is not applied and the part springs back. */
     reach: GizmoReach;
     view: ViewSettings;
@@ -61,6 +64,13 @@ export declare class FigureCanvas extends LitElement {
      * one that has outgrown it -- standing up again loses the selection and the camera.
      */
     private standUp;
+    /**
+     * A part's component state, kept for the part object it was made from while the palette and the board are the same: a
+     * size drag redraws the board every frame, and only the parts the frame moved are new objects (ADR-0140 4.4).
+     */
+    private made;
+    private madeFor?;
+    private componentFor;
     private components;
     /** The components standing now, by name. Not held between calls: the scene stands its board up again at times. */
     private standing;
@@ -72,9 +82,20 @@ export declare class FigureCanvas extends LitElement {
     private watchScene;
     /** Components the gizmo changed since the last commit, by part name. */
     private pending;
+    /** The handle each size drag held, by part name, from the scene's `scaleGrab` -- told with the release. */
+    private grabs;
+    private sizingFrame?;
+    /** Once an animation frame: where a size drag stands, told so the editor draws figure-model's result for it. */
+    private sizingSoon;
     private pointerDown;
     private commitTimer?;
+    /**
+     * The parts as they stood when the pointer went down. A drag is measured against them: while a size drag is drawn, the
+     * parts given are its frames (ADR-0140 4.4), and measured against those it grew on itself and its release wrote nothing.
+     */
+    private atPress?;
     private onPointerDown;
+    private pressedPart;
     private onPointerUp;
     private commitSoon;
     /** Tell each changed part once, in the inputs' terms; then put the board where the inputs say (a refusal springs back). */

package/dist-client/modeller/canvas.js

@@ -19,11 +19,15 @@ let FigureCanvas = class FigureCanvas extends LitElement {
         super(...arguments);
         this.parts = [];
         this.palette = {};
-        /** The face a size drag keeps, per part (figure-model's `figureScaleAnchorOf`), so the drag shows what is written. */
-        this.anchors = {};
         /** Which figure is open. Another one stands the board up again. */
         this.context = '';
         this.selected = '';
+        /**
+         * The fastening window is open (ADR-0140 stage 4): a part pressed is aimed at, not chosen -- told out as `part-aimed`
+         * with where the press landed (the scene's `pickedAt`: the point and the drawn triangle's outward normal, in the
+         * figure's frame), and the part being fastened stays chosen.
+         */
+        this.aiming = false;
         /** What the gizmo may write for the selected part; a change beyond it is not applied and the part springs back. */
         this.reach = { translate: false, rotate: false, scale: false };
         this.view = DEFAULT_VIEW;
@@ -45,11 +49,19 @@ let FigureCanvas = class FigureCanvas extends LitElement {
         this.marks = [];
         /** Set while this canvas writes to components, so the scene's echo of it is not taken for a drag. */
         this.writing = false;
+        /**
+         * A part's component state, kept for the part object it was made from while the palette and the board are the same: a
+         * size drag redraws the board every frame, and only the parts the frame moved are new objects (ADR-0140 4.4).
+         */
+        this.made = new WeakMap();
         /** Components the gizmo changed since the last commit, by part name. */
         this.pending = new Map();
+        /** The handle each size drag held, by part name, from the scene's `scaleGrab` -- told with the release. */
+        this.grabs = new Map();
         this.pointerDown = false;
         this.onPointerDown = () => {
             this.pointerDown = true;
+            this.atPress = new Map(this.parts.map(p => [p.id, p]));
         };
         this.onPointerUp = () => {
             if (!this.pointerDown)
@@ -94,7 +106,7 @@ let FigureCanvas = class FigureCanvas extends LitElement {
     updated(changed) {
         if (!this.hasUpdated)
             return;
-        if (['parts', 'palette', 'context', 'fan', 'anchors', 'ghost', 'highlight', 'marks'].some(key => changed.has(key)))
+        if (['parts', 'palette', 'context', 'fan', 'ghost', 'highlight', 'marks'].some(key => changed.has(key)))
             this.standUp();
         if (changed.has('view'))
             this.applyView();
@@ -201,8 +213,15 @@ let FigureCanvas = class FigureCanvas extends LitElement {
             this.dispatchEvent(new CustomEvent('render-error', { detail: error, bubbles: true, composed: true }));
         }
     }
+    componentFor(part) {
+        if (this.madeFor?.[0] !== this.palette || this.madeFor?.[1] !== this.board)
+            (this.made = new WeakMap()), (this.madeFor = [this.palette, this.board]);
+        if (!this.made.has(part))
+            this.made.set(part, componentOf(part, this.palette, this.board, true));
+        return this.made.get(part);
+    }
     components() {
-        const parts = this.parts.map(part => componentOf(part, this.palette, this.board, this.anchors[ownerOf(part.id)])).filter((c) => !!c);
+        const parts = this.parts.map(part => this.componentFor(part)).filter((c) => !!c);
         /* The fan in the accent colour, translucent; `capturable: false` keeps clicks, the marquee and the gizmo off it. */
         const fan = this.fan ? componentOf(this.fan, { ...this.palette, [JOINT_FAN]: this.palette['palette.accent'] ?? FAN_COLOUR }, this.board) : null;
         const accent = this.palette['palette.accent'] ?? FAN_COLOUR;
@@ -253,7 +272,15 @@ let FigureCanvas = class FigureCanvas extends LitElement {
                 const found = standing.get(name);
                 if (found) {
                     const diff = changedKeys(found.state, state);
-                    if (diff)
+                    /*
+                      A part whose size is being dragged keeps the size the gizmo gives it: what is drawn does not go back into what the
+                      gizmo measures (ADR-0140 4.4). Written back, a size the frame could not change (one that follows the figure) put
+                      the part back to its old size, and the release wrote nothing.
+                    */
+                    if (diff && this.pointerDown && this.grabs.has(name))
+                        for (const key of ['width', 'depth', 'height'])
+                            delete diff[key];
+                    if (diff && Object.keys(diff).length)
                         found.set(diff);
                     continue;
                 }
@@ -281,11 +308,35 @@ let FigureCanvas = class FigureCanvas extends LitElement {
             */
             if (!this.isConnected)
                 return;
+            /*
+              While aiming, a press is told by the click (below); the part being fastened is chosen again once the scene has
+              done with the pick -- put back while the scene was still telling it, the selection read right but the outline
+              stayed on the part pressed (:3300, 2026-10-20).
+            */
+            if (this.aiming) {
+                setTimeout(() => this.showSelected());
+                return;
+            }
             const name = after?.[0]?.state?.name;
             const id = typeof name === 'string' ? name : '';
             if (ownerOf(id) !== this.selected)
                 this.dispatchEvent(new CustomEvent('part-selected', { detail: id, bubbles: true, composed: true }));
         });
+        /*
+          A press while aiming: the part pressed -- the one being fastened too, which changes no selection and so is told by
+          no `selected` -- with where it landed (`pickedAt`, filled before the click is told). It comes up to the board
+          with the component in the last argument's `origin`, as a change does.
+        */
+        layer.on?.('click', (...args) => {
+            if (!this.aiming || !this.isConnected)
+                return;
+            const origin = args[args.length - 1]?.origin;
+            const id = origin?.state?.name;
+            if (typeof id !== 'string' || !id)
+                return;
+            const at = origin?.realObject?.pickedAt;
+            this.dispatchEvent(new CustomEvent('part-aimed', { detail: { id, ...(at ? { point: at.point, normal: at.normal } : {}) }, bubbles: true, composed: true }));
+        });
         /*
           A change comes up to the board with the component in the last argument's `origin` (the scene appends
           { origin, name, deliverer } as it bubbles). Reading the first argument as the component does nothing.
@@ -305,6 +356,12 @@ let FigureCanvas = class FigureCanvas extends LitElement {
             if (typeof name !== 'string' || !this.parts.some(p => p.id === name))
                 return;
             this.pending.set(name, origin);
+            /* A size drag: the scene tells the handle held; figure-model draws each frame from it (ADR-0140 4.4). */
+            const grab = origin.state?.scaleGrab;
+            if (this.pointerDown && grab) {
+                this.grabs.set(name, { ...grab });
+                this.sizingSoon(name);
+            }
             if (!this.pointerDown)
                 this.commitSoon(80);
         });
@@ -312,6 +369,24 @@ let FigureCanvas = class FigureCanvas extends LitElement {
         window.addEventListener('pointerup', this.onPointerUp, true);
         window.addEventListener('pointercancel', this.onPointerUp, true);
     }
+    /** Once an animation frame: where a size drag stands, told so the editor draws figure-model's result for it. */
+    sizingSoon(name) {
+        if (this.sizingFrame !== undefined)
+            return;
+        this.sizingFrame = requestAnimationFrame(() => {
+            this.sizingFrame = undefined;
+            const part = this.pressedPart(name);
+            const component = this.pending.get(name);
+            if (!part || !component || !this.board || !this.pointerDown)
+                return;
+            const result = { ...gizmoResultOf(part, component.state, this.board), grab: this.grabs.get(name) };
+            if (result.scale)
+                this.dispatchEvent(new CustomEvent('part-sizing', { detail: { id: part.id, result }, bubbles: true, composed: true }));
+        });
+    }
+    pressedPart(name) {
+        return this.atPress?.get(name) ?? this.parts.find(p => p.id === name);
+    }
     commitSoon(delay) {
         clearTimeout(this.commitTimer);
         this.commitTimer = setTimeout(() => this.commit(), delay);
@@ -327,15 +402,21 @@ let FigureCanvas = class FigureCanvas extends LitElement {
             return;
         const changed = [...this.pending];
         this.pending.clear();
+        if (this.sizingFrame !== undefined)
+            cancelAnimationFrame(this.sizingFrame);
+        this.sizingFrame = undefined;
         for (const [name, component] of changed) {
-            const part = this.parts.find(p => p.id === name);
+            const part = this.pressedPart(name);
             if (!part)
                 continue;
-            const result = gizmoResultOf(part, component.state, this.board);
+            const grab = this.grabs.get(name);
+            const result = { ...gizmoResultOf(part, component.state, this.board), ...(grab ? { grab } : {}) };
             if (!result.position && !result.rotation && !result.scale)
                 continue;
             this.dispatchEvent(new CustomEvent('part-transformed', { detail: { id: part.id, result }, bubbles: true, composed: true }));
         }
+        this.grabs.clear();
+        this.atPress = undefined;
         setTimeout(() => this.sync());
     }
     showSelected() {
@@ -362,6 +443,10 @@ let FigureCanvas = class FigureCanvas extends LitElement {
     teardown() {
         clearTimeout(this.commitTimer);
         this.pending.clear();
+        this.grabs.clear();
+        if (this.sizingFrame !== undefined)
+            cancelAnimationFrame(this.sizingFrame);
+        this.sizingFrame = undefined;
         this.stage?.removeEventListener('pointerdown', this.onPointerDown, true);
         window.removeEventListener('pointerup', this.onPointerUp, true);
         window.removeEventListener('pointercancel', this.onPointerUp, true);
@@ -379,10 +464,6 @@ __decorate([
     property({ attribute: false }),
     __metadata("design:type", Object)
 ], FigureCanvas.prototype, "palette", void 0);
-__decorate([
-    property({ attribute: false }),
-    __metadata("design:type", Object)
-], FigureCanvas.prototype, "anchors", void 0);
 __decorate([
     property(),
     __metadata("design:type", Object)
@@ -391,6 +472,10 @@ __decorate([
     property(),
     __metadata("design:type", Object)
 ], FigureCanvas.prototype, "selected", void 0);
+__decorate([
+    property({ type: Boolean }),
+    __metadata("design:type", Object)
+], FigureCanvas.prototype, "aiming", void 0);
 __decorate([
     property({ attribute: false }),
     __metadata("design:type", Object)