@salsita-ai/sdk 0.0.0-stage → 0.49.0-develop.cbee856178

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorArrowHeadTriangle.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from 'react';
+import type { DimensionIndicatorArrowHeadProps } from './dimension-indicator-arrow-head-types.js';
+/**
+ * @group Components
+ * @category 3D
+ */
+export declare const DimensionIndicatorArrowHeadTriangle: ({ startPoint, endPoint, extrusion, size, color, opacity, renderOrder, }: Omit<DimensionIndicatorArrowHeadProps, 'type'>) => ReactElement;

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorArrowHeadTriangle.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import{useMemo as r}from"react";import{DoubleSide as o,ShapeGeometry as t}from"three";export const DimensionIndicatorArrowHeadTriangle=({startPoint:a,endPoint:n,extrusion:i,size:l,color:m,opacity:d,renderOrder:c})=>e("mesh",{geometry:r(()=>{let e=n.clone().sub(a).normalize().multiplyScalar(l),r=i.clone().normalize().multiplyScalar(l/3),o=a.clone().add(e),m=o.clone().add(r),d=o.clone().sub(r);return new t().setFromPoints([a,m,d])},[a,n,i,l]),renderOrder:c,children:e("meshStandardMaterial",{depthTest:void 0===c,color:m,opacity:d,transparent:void 0!==c,side:o})});

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorHelpers.d.ts

@@ -0,0 +1 @@
+export declare const measureTextWidth: (text: string, fontSize?: number, fontFace?: string) => number;

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorHelpers.js

@@ -0,0 +1 @@
+import e from"lodash-es/memoize.js";let t=e(()=>document.createElement("canvas").getContext("2d"));export const measureTextWidth=(e,o=1,m="Roboto")=>{let r=o<100?100:1,n=t();return n.font=`${o*r}px ${m}`,1.1*n.measureText(e).width/r};

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorInternal.d.ts

@@ -0,0 +1,131 @@
+import type { ReactElement } from 'react';
+import { type Vector3 } from 'three';
+import { ArrowHeadType } from '#package/domain';
+interface DimensionIndicatorProps {
+    /** Start point of measured edge */
+    startPoint: Vector3;
+    /** End point of measured edge */
+    endPoint: Vector3;
+    /** Extrusion vector determines where the indicator is shown in relation to the measured edge. */
+    extrusion: Vector3;
+    /** Indicator label. */
+    label: string;
+    /** Color of label as RGB value */
+    labelColor: number;
+    /** Padding between label and indicator line */
+    labelPadding: number;
+    /** Font size of the indicator label. */
+    labelFontSize: number;
+    /** Font that will be used the label. Path to font file in TTF or WOFF format */
+    labelFont?: string;
+    /** Rotation of the label in radians. */
+    labelAngle: number;
+    /** Offset of the label in relation to the indicator line center. */
+    labelOffset: Vector3;
+    /** Specify the arrow head type at the start of the indicator. */
+    arrowHeadTypeStart: ArrowHeadType;
+    /** Specify the arrow head type at the end of the indicator. */
+    arrowHeadTypeEnd: ArrowHeadType;
+    /** Arrow head size. */
+    arrowHeadSize: number;
+    /**
+     * For small distances, there may be insufficient space to display the label and arrows of the specified size
+     * between the start and end points. If true, the arrows will automatically move so that they point inwards
+     * when this happens, with only the label being displayed in between.
+     */
+    arrowsMoveOutside: boolean;
+    /** Set to true to make the indicator line dashed. */
+    indicatorLineDashed: boolean;
+    /** Color of indicator line as RGB value */
+    indicatorLineColor: number;
+    /** Width of indicator line */
+    indicatorLineWidth: number;
+    /** Set to true to make the extrusion line dashed. */
+    extrusionLineDashed: boolean;
+    /** Color of extrusion line as RGB value */
+    extrusionLineColor: number;
+    /** Width of extrusion line */
+    extrusionLineWidth: number;
+    /** Scale of line dash. Larger values increase granularity. Default is 50. */
+    dashScale: number;
+    /** Size of dash and gap. */
+    dashSize: number;
+    /** If true, indicator will always render over other objects in view. Default is true */
+    indicatorAlwaysVisible?: boolean;
+    /**
+     * This value allows the default rendering order of scene graph objects to be overridden
+     * although opaque and transparent objects remain sorted independently.
+     * When this property is set for an instance of Group, all descendants objects
+     * will be sorted and rendered together. Sorting is from lowest to highest renderOrder.
+     */
+    renderOrder?: number;
+    /**
+     * Float in the range of 0.0 - 1.0 indicating how transparent the material is.
+     * A value of 0.0 indicates fully transparent, 1.0 is fully opaque.
+     * Sets the opacity for all parts of the indicator. Can be overriden for some parts
+     */
+    opacity?: number;
+    /**
+     * Optional string containing all possible characters that will be rendered. Should have positive effect on rendering effectivity if provided.
+     */
+    characters?: string;
+    /** Base direction for the text. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelDirection?: 'auto' | 'ltr' | 'rtl';
+    /** Opacity of the glyph's fill area (0-1). See https://protectwise.github.io/troika/troika-three-text/ */
+    labelFillOpacity?: number;
+    /** Font style. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelFontStyle?: 'normal' | 'italic';
+    /** Font weight. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelFontWeight?: number | 'normal' | 'bold';
+    /** Spacing between letters. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelLetterSpacing?: number;
+    /** Line height as a multiple of the font size. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelLineHeight?: number;
+    /** Maximum width of the text block. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelMaxWidth?: number;
+    /** Blur radius for the text outline. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineBlur?: number | string;
+    /** Color for the text outline. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineColor?: number;
+    /** Horizontal offset for the text outline. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineOffsetX?: number | string;
+    /** Vertical offset for the text outline. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineOffsetY?: number | string;
+    /** Opacity of the text outline (0-1). See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineOpacity?: number;
+    /** Width of the text outline. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOutlineWidth?: number | string;
+    /** Text wrapping behavior. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelOverflowWrap?: 'normal' | 'break-word';
+    /** Color of the stroke. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelStrokeColor?: number;
+    /** Opacity of the stroke (0-1). See https://protectwise.github.io/troika/troika-three-text/ */
+    labelStrokeOpacity?: number;
+    /** Width of the stroke. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelStrokeWidth?: number | string;
+    /** Whitespace handling. See https://protectwise.github.io/troika/troika-three-text/ */
+    labelWhiteSpace?: 'normal' | 'nowrap' | 'pre-wrap';
+    /** Width of the outline behind indicator lines */
+    indicatorLineOutlineWidth?: number;
+    /** Color of the indicator line outline as RGB value */
+    indicatorLineOutlineColor?: number;
+    /** Width of the outline behind extrusion lines */
+    extrusionLineOutlineWidth?: number;
+    /** Color of the extrusion line outline as RGB value */
+    extrusionLineOutlineColor?: number;
+    /**
+     * Whether the indicator should be sized in screen space (pixels) rather than world units.
+     * When true, font size and arrow head size are automatically converted to world units
+     * so the indicator keeps a visually stable size on the screen regardless of zoom or distance.
+     * When false (default), the provided values are treated as world units without screen-space conversion.
+     */
+    screenSized?: boolean;
+    /** Optional reference point at the end side, used for rendering a projection line. */
+    endReferencePoint?: Vector3;
+    /** Optional prefix rendered before the label text, separated by a space. */
+    labelPrefix?: string | null;
+    /** Color of the label prefix as RGB value. */
+    labelPrefixFontColor?: number;
+}
+export declare const DimensionIndicatorInternal: (props: DimensionIndicatorProps) => ReactElement | null;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/DimensionIndicatorInternal.js

@@ -0,0 +1 @@
+import{jsx as e,jsxs as t,Fragment as i}from"react/jsx-runtime";import{Billboard as r,Line as o,ScreenSizer as n,Text as d}from"@react-three/drei";import{Suspense as a,useMemo as l,useRef as s}from"react";import{Euler as p}from"three";import{ArrowHeadType as c}from"#package/domain";import{usePixelWorldSize as h}from"../../three/use-pixel-world-size.js";import{SuspendedBoundary as m}from"../SuspendedBoundary.js";import{DimensionIndicatorArrowHead as f}from"./DimensionIndicatorArrowHead.js";import{useCalculatePoints as u}from"./use-calculate-points.js";export const DimensionIndicatorInternal=S=>{let{startPoint:g,endPoint:v,extrusion:z,label:O,labelColor:W,labelAngle:y,labelFontSize:j,labelPadding:w,arrowHeadSize:x,labelOffset:k,dashScale:P,dashSize:T,arrowHeadTypeStart:b,arrowHeadTypeEnd:H,arrowsMoveOutside:N,indicatorLineDashed:B,indicatorLineColor:E,indicatorLineWidth:I,extrusionLineDashed:C,extrusionLineColor:D,extrusionLineWidth:F,labelFont:$,indicatorAlwaysVisible:A=!0,renderOrder:M,opacity:X=1,characters:Y,labelDirection:q,labelFillOpacity:G,labelFontStyle:J,labelFontWeight:K,labelLetterSpacing:L,labelLineHeight:Q,labelMaxWidth:R,labelOutlineBlur:U,labelOutlineColor:V,labelOutlineOffsetX:Z,labelOutlineOffsetY:_,labelOutlineOpacity:ee,labelOutlineWidth:et,labelOverflowWrap:ei,labelStrokeColor:er,labelStrokeOpacity:eo,labelStrokeWidth:en,labelWhiteSpace:ed,indicatorLineOutlineWidth:ea,indicatorLineOutlineColor:el,extrusionLineOutlineWidth:es,extrusionLineOutlineColor:ep,screenSized:ec=!1,endReferencePoint:eh,labelPrefix:em,labelPrefixFontColor:ef}=S,eu=s(null),eS=h(eu,.1,ec),eg=em&&O?`${em} ${O}`:O,ev=j*(ec?eS:1),ez=w*(ec?eS:1),eO=x*(ec?eS:1),eW=x*(ec?eS:1),{indicatorCenter:ey,startArrowTip:ej,startArrowBase:ew,endArrowTip:ex,endArrowBase:ek,startLine:eP,endLine:eT,showIndicatorLine:eb}=u({startPoint:g,endPoint:v,extrusion:z,labelPadding:ez,label:eg,labelFontSize:ev,labelOffset:k,arrowHeadSizeStart:b===c.NONE?0:eO,arrowHeadSizeEnd:H===c.NONE?0:eW,arrowsMoveOutside:N}),eH=M??(A?200:void 0),eN=l(()=>new p(0,0,y),[y]),eB=l(()=>ey.clone().add(k),[ey,k]),eE={depthTest:!A,transparent:A,renderOrder:eH,opacity:X},eI={color:E,lineWidth:I,dashed:!!B,...B?{gapSize:T,dashSize:T,dashScale:P}:{},...eE},eC={color:D,lineWidth:F,dashed:!!C,...C?{gapSize:T,dashSize:T,dashScale:P}:{},...eE},eD=void 0!==eH?eH-1:void 0,eF=void 0!==ea?{color:el??0,lineWidth:ea,dashed:!!B,...B?{gapSize:T,dashSize:T,dashScale:P}:{},depthTest:!A,transparent:A,renderOrder:eD,opacity:X}:void 0,e$=void 0!==es?{color:ep??0,lineWidth:es,dashed:!!C,...C?{gapSize:T,dashSize:T,dashScale:P}:{},depthTest:!A,transparent:A,renderOrder:eD,opacity:X}:void 0,eA={color:E,opacity:X,extrusion:z,renderOrder:M},eM=l(()=>em&&void 0!==ef?{0:ef,[em.length+1]:W}:void 0,[em,ef,W]),eX=t(d,{font:$,color:W,fontSize:j,renderOrder:void 0!==eH?eH+2:void 0,characters:Y,rotation:eN,direction:q,fillOpacity:G??1,letterSpacing:L,lineHeight:Q,maxWidth:R,outlineBlur:U,outlineColor:V,outlineOffsetX:Z,outlineOffsetY:_,outlineOpacity:ee,outlineWidth:et,overflowWrap:ei,strokeColor:er,strokeOpacity:eo,strokeWidth:en,...{fontStyle:J,fontWeight:K,whiteSpace:ed,colorRanges:eM},children:[e("meshBasicMaterial",{depthTest:!A,opacity:X,transparent:A}),eg]});return t(a,{fallback:null,children:[e$&&t(i,{children:[e(o,{points:[g,ej],...e$}),e(o,{points:[v,ex],...e$})]}),e(o,{points:[g,ej],...eC}),e(o,{points:[v,ex],...eC}),eh&&eh.distanceTo(v)>1e-4&&t(i,{children:[e$&&e(o,{points:[eh,v],...e$}),e(o,{points:[eh,v],...eC})]}),eb&&t(i,{children:[eF&&t(i,{children:[e(o,{points:[ew,eP],...eF}),e(o,{points:[ek,eT],...eF})]}),e(f,{startPoint:ej,endPoint:ew,type:b,size:eO,...eA}),e(f,{startPoint:ex,endPoint:ek,type:H,size:eW,...eA}),e(o,{points:[ew,eP],...eI}),e(o,{points:[ek,eT],...eI})]}),t(r,{position:eB,children:[e("group",{ref:eu}),e(m,{children:ec?e(n,{scale:1,children:eX}):eX})]})]})};

package/dist/configurator/scene/scene-entity/dimension-indicators/OffsetIndicator.d.ts

@@ -0,0 +1,21 @@
+import { type DomainEntityId } from '#package/domain';
+import { type DimensionIndicatorProps } from './DimensionIndicator.js';
+interface Props extends Omit<DimensionIndicatorProps, 'startX' | 'startY' | 'startZ' | 'endX' | 'endY' | 'endZ'> {
+    readonly entityId: DomainEntityId<string>;
+    readonly targetEntityOffsetAnchors: readonly string[];
+    readonly targetReferenceOffsetAnchors: readonly string[];
+    readonly referenceEntityIds?: ReadonlyArray<DomainEntityId<string>> | null;
+    readonly directionVector: {
+        readonly x?: number;
+        readonly y?: number;
+        readonly z?: number;
+    };
+    readonly directionVectorRelativeToEntityId?: DomainEntityId<string> | null;
+    readonly maxDistance?: number | null;
+    readonly minDistance?: number | null;
+    readonly maxPerpendicularDistance?: number | null;
+    readonly minPerpendicularDistance?: number | null;
+}
+declare const OffsetIndicatorInstanceComponent: (props: Props) => import("react/jsx-runtime").JSX.Element | null;
+export declare const OffsetIndicatorInstance: import("react").MemoExoticComponent<typeof OffsetIndicatorInstanceComponent>;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/OffsetIndicator.js

@@ -0,0 +1 @@
+import{jsx as e}from"react/jsx-runtime";import{memo as n}from"react";import{DimensionIndicator as t}from"./DimensionIndicator.js";import{useOffsetIndicator as r}from"./use-offset-indicator.js";export const OffsetIndicatorInstance=n(n=>{let{entityId:s,targetEntityOffsetAnchors:o,targetReferenceOffsetAnchors:i,referenceEntityIds:d,directionVector:a,directionVectorRelativeToEntityId:c,maxDistance:f,minDistance:u,maxPerpendicularDistance:m,minPerpendicularDistance:x,extrusionX:X,extrusionY:Y,extrusionZ:Z,...l}=n,R=r({entityId:s,targetEntityOffsetAnchors:o,targetReferenceOffsetAnchors:i,referenceEntityIds:d,directionVector:a,directionVectorRelativeToEntityId:c,maxDistance:f,minDistance:u,maxPerpendicularDistance:m,minPerpendicularDistance:x,extrusionX:X,extrusionY:Y,extrusionZ:Z});return null===R?null:e(t,{...l,value:R.signedProjectedDistance,startX:R.startX,startY:R.startY,startZ:R.startZ,endX:R.endX,endY:R.endY,endZ:R.endZ,endReferenceX:R.endReferenceX,endReferenceY:R.endReferenceY,endReferenceZ:R.endReferenceZ,extrusionX:R.extrusionX,extrusionY:R.extrusionY,extrusionZ:R.extrusionZ})});

package/dist/configurator/scene/scene-entity/dimension-indicators/SceneEntityDimensionIndicators.d.ts

@@ -0,0 +1,7 @@
+import { type DomainEntity, type EntityId } from '#package/domain';
+interface Props {
+    id: EntityId<DomainEntity<string>>;
+}
+declare const Component: (props: Props) => import("react/jsx-runtime").JSX.Element | null;
+export declare const SceneEntityDimensionIndicators: import("react").MemoExoticComponent<typeof Component>;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/SceneEntityDimensionIndicators.js

@@ -0,0 +1 @@
+import{jsx as n,Fragment as t}from"react/jsx-runtime";import{memo as e}from"react";import{angleIndicatorComponent as r,dimensionIndicatorComponent as o,isAngleIndicatorSnapshot as i,isDimensionIndicatorSnapshot as a,isDomainEntityId as m,isOffsetIndicatorSnapshot as s,offsetIndicatorComponent as c}from"#package/domain";import{useEagerObservableValue as p,useRenderedComponents as d}from"#package/react-sdk";import{useConfigurator as f}from"../../../application-runtime/index.js";import{SuspendedBoundary as l}from"../SuspendedBoundary.js";import{AngleIndicatorInstance as I}from"./AngleIndicatorInstance.js";import{DimensionIndicator as u}from"./DimensionIndicator.js";import{OffsetIndicatorInstance as h}from"./OffsetIndicator.js";export const SceneEntityDimensionIndicators=e(e=>{let{id:j}=e,{canvasSystem:y}=f(),g=d({entityIds:[j],componentTypes:[o,c,r]}),k=p(y.dimensionIndicatorShown$),x=g.filter(n=>(k||!0===n.state.force)&&!1!==n.state.visible);return 0===x.length?null:n(t,{children:x.map(t=>{if(a(t))return n(l,{children:n(u,{...t.state})},t.componentInstance.instanceName);if(s(t)&&m(j))return n(l,{children:n(h,{entityId:j,...t.state})},t.componentInstance.instanceName);if(i(t))return n(l,{children:n(I,{state:t.state})},t.componentInstance.instanceName);throw Error(`Unknown indicator type: ${t.componentInstance.componentType.name}`)})})});

package/dist/configurator/scene/scene-entity/dimension-indicators/dimension-indicator-arrow-head-types.d.ts

@@ -0,0 +1,12 @@
+import type { Vector3 } from 'three';
+import { type ArrowHeadType } from '#package/domain';
+export interface DimensionIndicatorArrowHeadProps {
+    type?: ArrowHeadType;
+    startPoint: Vector3;
+    endPoint: Vector3;
+    extrusion: Vector3;
+    size: number;
+    color: number;
+    opacity: number;
+    renderOrder: number | undefined;
+}

package/dist/configurator/scene/scene-entity/dimension-indicators/dimension-indicator-arrow-head-types.js

@@ -0,0 +1 @@
+export{};

package/dist/configurator/scene/scene-entity/dimension-indicators/offset-indicator-matching.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Pure geometry functions for the offset indicator algorithm.
+ *
+ * These functions find the closest reference entity along a direction vector and compute
+ * the anchor pair + projection needed to render the indicator. All inputs are pre-transformed
+ * world-space coordinates — no React, no system dependencies.
+ *
+ * The algorithm works in 2D projections for perpendicular overlap checks:
+ * anchor points are projected onto a plane perpendicular to the direction vector,
+ * convex hulls are built, and the Separating Axis Theorem (SAT) determines overlap/gap.
+ */
+import type { Matrix4 } from 'three';
+import { Vector3 } from 'three';
+import { type DomainEntityId } from '#package/domain';
+/** A point in the 2D plane perpendicular to the direction vector. */
+interface Point2D {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * Compute the convex hull of a set of 2D points using the Graham scan algorithm.
+ * Returns vertices in counter-clockwise order.
+ *
+ * Handles edge cases: empty input, duplicate points, and collinear points
+ * (returns the two extreme points for collinear sets).
+ *
+ * Exported for testing only.
+ */
+export declare function convexHull2D(points: readonly Point2D[]): readonly Point2D[];
+/**
+ * Compute the signed distance between two convex hulls.
+ * - Positive: hulls are separated (gap between them)
+ * - Negative: hulls overlap (penetration depth, approximated via SAT min-overlap)
+ * - Infinity: one or both hulls are empty
+ *
+ * Uses the Separating Axis Theorem (SAT) to detect overlap: projects both hulls
+ * onto each edge normal and checks for interval separation. If all axes show overlap,
+ * the hulls intersect and the minimum overlap is returned as negative penetration depth.
+ * If any axis shows separation, the exact unsigned distance is computed via
+ * brute-force vertex-to-edge checks.
+ *
+ * Special cases for single-point hulls use containment checks for sign determination.
+ *
+ * Exported for testing only.
+ */
+export declare function signedHullDistance(hullA: readonly Point2D[], hullB: readonly Point2D[]): number;
+/** Result of the offset indicator computation, in entity-local space for rendering. */
+export interface OffsetIndicatorResult {
+    /** Start anchor point (on this entity) — entity-local coordinates. */
+    readonly startX: number;
+    readonly startY: number;
+    readonly startZ: number;
+    /** End point (projection of endReference onto direction line through start) — entity-local coordinates. */
+    readonly endX: number;
+    readonly endY: number;
+    readonly endZ: number;
+    /** Reference anchor point (on the winning reference entity) — entity-local coordinates. */
+    readonly endReferenceX: number;
+    readonly endReferenceY: number;
+    readonly endReferenceZ: number;
+    /** Extrusion vector transformed to entity-local space (for extrusion line rendering). */
+    readonly extrusionX: number;
+    readonly extrusionY: number;
+    readonly extrusionZ: number;
+    /**
+     * Signed projected distance along the direction vector from start to end.
+     * Negative when the reference entity overlaps this entity along the direction.
+     * Used for the indicator label (preserves sign, unlike Euclidean start→end distance).
+     */
+    readonly signedProjectedDistance: number;
+    /** Direction vector in parent world space (unit length). */
+    readonly directionX: number;
+    readonly directionY: number;
+    readonly directionZ: number;
+}
+/**
+ * A candidate reference entity with its best anchor pair.
+ * Produced by {@link findBestAnchorPairs}, consumed by {@link findWinningCandidate}.
+ */
+export interface OffsetCandidate {
+    readonly entityId: DomainEntityId<string>;
+    /** Signed projected distance along the direction vector for the best pair. */
+    readonly bestProjectedDist: number;
+    /** The anchor on this entity (in parent world space). */
+    readonly bestStart: Vector3;
+    /** The anchor on the reference entity (in parent world space). */
+    readonly bestEndRef: Vector3;
+}
+/** Filter parameters for {@link findWinningCandidate}. */
+export interface OffsetMatchParams {
+    /** Min projected distance along direction. Default: 0. Null disables the check. */
+    readonly minDistance: number | null | undefined;
+    /** Max signed perpendicular hull distance. Default: 0 (must touch/overlap). */
+    readonly maxPerpendicularDistance: number | null | undefined;
+    /** Min signed perpendicular hull distance. Default: null (no check). */
+    readonly minPerpendicularDistance: number | null | undefined;
+}
+/**
+ * Find the best anchor pair per reference entity and return sorted candidates.
+ *
+ * For each reference entity, tests all (thisAnchor, refAnchor) pairs and selects the one
+ * with the smallest signed projected distance along the direction vector. On tie (within
+ * epsilon), the pair with the smaller perpendicular offset wins — this ensures the most
+ * "aligned" pair is chosen when multiple pairs have equivalent projected distance.
+ *
+ * @param thisAnchors - This entity's anchors in parent world space.
+ * @param refAnchorsByEntity - Map of reference entity ID → anchors in parent world space.
+ * @param direction - Normalized direction vector in parent world space.
+ * @param maxDistance - Skip pairs with projected distance > maxDistance (early filter).
+ *   Null disables the filter.
+ * @returns Candidates sorted by projected distance, tiebroken by entity ID for determinism.
+ */
+export declare function findBestAnchorPairs(thisAnchors: readonly Vector3[], refAnchorsByEntity: ReadonlyMap<DomainEntityId<string>, readonly Vector3[]>, direction: Vector3, maxDistance: number | null | undefined): readonly OffsetCandidate[];
+/**
+ * Walk sorted candidates (closest first) and apply minDistance + perpendicular hull checks.
+ * Returns the first candidate that passes all checks, or null if none qualify.
+ *
+ * For each candidate:
+ * 1. Check minDistance on the projected distance — skip candidates too close (cheap, avoids hull work).
+ * 2. Project both entities' anchor sets onto the plane perpendicular to the direction vector.
+ * 3. Build convex hulls and compute signed perpendicular hull distance (negative = overlap, positive = gap).
+ * 4. Check against [minPerpendicularDistance, maxPerpendicularDistance] range.
+ *
+ * @param candidates - Sorted output of {@link findBestAnchorPairs}.
+ * @param thisAnchors - This entity's anchors in parent world space (for hull projection).
+ * @param refAnchorsByEntity - All reference anchors by entity (for hull projection).
+ * @param direction - Normalized direction vector in parent world space.
+ * @param params - Distance filter parameters.
+ */
+export declare function findWinningCandidate(candidates: readonly OffsetCandidate[], thisAnchors: readonly Vector3[], refAnchorsByEntity: ReadonlyMap<DomainEntityId<string>, readonly Vector3[]>, direction: Vector3, params: OffsetMatchParams): OffsetCandidate | null;
+/**
+ * Compute the final indicator geometry from the winning anchor pair.
+ *
+ * Given the winning pair (start on this entity, endRef on reference entity) and the
+ * projected distance, computes:
+ * - `end` = projection of endReference onto the direction vector line through start
+ * - Converts all three points from parent world space to entity-local space for rendering
+ *
+ * Pure: operates in a single coordinate frame (the default dimension unit). The
+ * caller is responsible for any `distanceDataUnit` conversions on the inputs
+ * and outputs.
+ *
+ * @param bestStart - Winning anchor on this entity (parent world space).
+ * @param bestEndRef - Winning anchor on the reference entity (parent world space).
+ * @param bestProjectedDist - Signed projected distance along direction (start → endRef).
+ * @param direction - Normalized direction vector in parent world space.
+ * @param entityWorldMatrix - This entity's world matrix (for inverse transform to local space).
+ * @param parentWorldMatrix - This entity's parent world matrix (for parent-world → world → local).
+ * @param localExtrusion - Extrusion vector already transformed to entity-local space.
+ * @returns Indicator geometry in entity-local space.
+ */
+export declare function computeIndicatorGeometry(bestStart: Vector3, bestEndRef: Vector3, bestProjectedDist: number, direction: Vector3, entityWorldMatrix: Matrix4, parentWorldMatrix: Matrix4, localExtrusion: Vector3): OffsetIndicatorResult;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/offset-indicator-matching.js

@@ -0,0 +1 @@
+import{Vector3 as t}from"three";import{DIMENSION_EPSILON as e}from"#package/domain";function n(t,e,n){return{x:t.dot(e),y:t.dot(n)}}function l(t,e,n){return(e.x-t.x)*(n.y-t.y)-(e.y-t.y)*(n.x-t.x)}export function convexHull2D(t){if(t.length<=1)return t;if(2===t.length){let e=t[0],n=t[1];return e.x===n.x&&e.y===n.y?[e]:t}let e=0;for(let n=1;n<t.length;n++){let l=t[n],r=t[e];(l.y<r.y||l.y===r.y&&l.x<r.x)&&(e=n)}let n=t[e],r=t.filter((t,n)=>n!==e).sort((t,e)=>{let r=l(n,t,e);return 1e-10>Math.abs(r)?(t.x-n.x)**2+(t.y-n.y)**2-((e.x-n.x)**2+(e.y-n.y)**2):-r}),i=[n];for(let t of r){for(;i.length>1;){let e=i[i.length-1];if(0>=l(i[i.length-2],e,t))i.pop();else break}i.push(t)}return 1===i.length&&r.length>0?[n,r[r.length-1]]:i}function r(t,e,n){let l=n.x-e.x,r=n.y-e.y,i=l*l+r*r;if(i<1e-20)return(t.x-e.x)**2+(t.y-e.y)**2;let o=Math.max(0,Math.min(1,((t.x-e.x)*l+(t.y-e.y)*r)/i)),a=e.x+o*l,x=e.y+o*r;return(t.x-a)**2+(t.y-x)**2}function i(t,e){let n=1/0;for(let l of t)for(let t=0;t<e.length;t++){let i=(t+1)%e.length;n=Math.min(n,r(l,e[t],e[i]))}for(let l of e)for(let e=0;e<t.length;e++){let i=(e+1)%t.length;n=Math.min(n,r(l,t[e],t[i]))}return Math.sqrt(n)}function o(t,e){if(e.length<=2)return!1;for(let n=0;n<e.length;n++){let r=(n+1)%e.length;if(-1e-10>l(e[n],e[r],t))return!1}return!0}export function signedHullDistance(t,e){if(0===t.length||0===e.length)return 1/0;if(1===t.length&&1===e.length){let n=t[0],l=e[0];return Math.sqrt((n.x-l.x)**2+(n.y-l.y)**2)}if(1===t.length)return o(t[0],e)?-i(t,e)||-1e-10:i(t,e);if(1===e.length)return o(e[0],t)?-i(t,e)||-1e-10:i(t,e);if(t.length<=2&&e.length<=2){let n=t[0],l=t[1]??n,r=e[0],i=e[1]??r,o=l.x-n.x,a=l.y-n.y;o*o+a*a<1e-20&&(o=i.x-r.x,a=i.y-r.y);let x=o*o+a*a;if(x<1e-20)return Math.sqrt((n.x-r.x)**2+(n.y-r.y)**2);let f=n.x*o+n.y*a,h=l.x*o+l.y*a,u=r.x*o+r.y*a,y=i.x*o+i.y*a,c=Math.min(f,h),s=Math.min(u,y);return-(Math.min(Math.max(f,h),Math.max(u,y))-Math.max(c,s))/Math.sqrt(x)}let n=[],l=t=>{for(let e=0;e<t.length;e++){let l=(e+1)%t.length,r=t[e],i=t[l],o=-(i.y-r.y),a=i.x-r.x,x=Math.sqrt(o*o+a*a);x>1e-10&&n.push({x:o/x,y:a/x})}};if(l(t),l(e),0===n.length)return 1/0;let r=!1,a=1/0,x=1/0;for(let l of n){let n=1/0,i=-1/0;for(let e of t){let t=e.x*l.x+e.y*l.y;n=Math.min(n,t),i=Math.max(i,t)}let o=1/0,f=-1/0;for(let t of e){let e=t.x*l.x+t.y*l.y;o=Math.min(o,e),f=Math.max(f,e)}let h=Math.min(i,f)-Math.max(n,o);h<=0?(r=!0,a=Math.min(a,-h)):x=Math.min(x,h)}return r?i(t,e):-x}export function findBestAnchorPairs(t,n,l,r){let i=[];for(let[o,a]of n){let n=1/0,x=1/0,f=null,h=null;for(let i of t)for(let t of a){let o=t.clone().sub(i),a=o.dot(l);if(null==r||!(a>r+e)){if(a<n-e)n=a,x=o.clone().addScaledVector(l,-a).lengthSq(),f=i,h=t;else if(Math.abs(a-n)<=e){let r=o.clone().addScaledVector(l,-a).lengthSq();r<x-e&&(n=a,x=r,f=i,h=t)}}}f&&h&&i.push({entityId:o,bestProjectedDist:n,bestStart:f,bestEndRef:h})}return i.sort((t,n)=>{let l=t.bestProjectedDist-n.bestProjectedDist;return Math.abs(l)>e?l:t.entityId<n.entityId?-1:+(t.entityId>n.entityId)}),i}export function findWinningCandidate(l,r,i,o,a){let x,f,h,u,y,c,s,d,g;if(0===l.length)return null;let{u:M,v:m}=(x=new t(1,0,0),f=new t(0,1,0),h=new t(0,0,1),u=Math.abs(o.dot(x)),y=Math.abs(o.dot(f)),c=Math.abs(o.dot(h)),s=u<=y&&u<=c?x:y<=c?f:h,d=new t().crossVectors(o,s).normalize(),g=new t().crossVectors(o,d),{u:d,v:g}),p=convexHull2D(r.map(t=>n(t,M,m))),D=void 0===a.minDistance?0:a.minDistance,b=a.maxPerpendicularDistance??0;for(let t of l){if(null!==D&&t.bestProjectedDist<D-e)continue;let l=i.get(t.entityId);if(!l)continue;let r=signedHullDistance(p,convexHull2D(l.map(t=>n(t,M,m))));if(!(r>b+e)&&(null==a.minPerpendicularDistance||!(r<a.minPerpendicularDistance-e)))return t}return null}export function computeIndicatorGeometry(t,e,n,l,r,i,o){let a=t.clone().add(l.clone().multiplyScalar(n)),x=r.clone().invert(),f=t.clone().applyMatrix4(i).applyMatrix4(x),h=a.clone().applyMatrix4(i).applyMatrix4(x),u=e.clone().applyMatrix4(i).applyMatrix4(x);return{startX:f.x,startY:f.y,startZ:f.z,endX:h.x,endY:h.y,endZ:h.z,endReferenceX:u.x,endReferenceY:u.y,endReferenceZ:u.z,extrusionX:o.x,extrusionY:o.y,extrusionZ:o.z,signedProjectedDistance:n,directionX:l.x,directionY:l.y,directionZ:l.z}}

package/dist/configurator/scene/scene-entity/dimension-indicators/use-calculate-points.d.ts

@@ -0,0 +1,25 @@
+import { Vector3 } from 'three';
+interface CalculatePointsProps {
+    startPoint: Vector3;
+    endPoint: Vector3;
+    extrusion: Vector3;
+    labelPadding: number;
+    label: string;
+    labelFontSize: number;
+    labelOffset: Vector3;
+    arrowHeadSizeStart: number;
+    arrowHeadSizeEnd: number;
+    arrowsMoveOutside: boolean;
+}
+interface CalculatePointsResult {
+    indicatorCenter: Vector3;
+    startArrowTip: Vector3;
+    startArrowBase: Vector3;
+    startLine: Vector3;
+    endArrowTip: Vector3;
+    endArrowBase: Vector3;
+    endLine: Vector3;
+    showIndicatorLine: boolean;
+}
+export declare const useCalculatePoints: ({ startPoint, endPoint, extrusion, labelPadding, label, labelFontSize, labelOffset, arrowHeadSizeStart, arrowHeadSizeEnd, arrowsMoveOutside, }: CalculatePointsProps) => CalculatePointsResult;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/use-calculate-points.js

@@ -0,0 +1 @@
+import{useMemo as e}from"react";import{Vector3 as l}from"three";import{measureTextWidth as n}from"./DimensionIndicatorHelpers.js";export const useCalculatePoints=({startPoint:o,endPoint:c,extrusion:r,labelPadding:t,label:a,labelFontSize:i,labelOffset:d,arrowHeadSizeStart:m,arrowHeadSizeEnd:s,arrowsMoveOutside:u})=>{let[p,h,b]=e(()=>[c.clone().sub(o),o.clone().add(r),c.clone().add(r)],[o,c,r]),f=e(()=>h.clone().lerp(b,.5),[h,b]),g=e(()=>p.clone().normalize(),[p]),y=e(()=>{let e=n(a,i)/2;return 0===e||d.length()>0?new l(0,0,0):g.clone().multiplyScalar(e+t)},[g,a,i,t,d]),S=e(()=>p.length()>2*y.length()+m+s,[p,y,m,s]),w=e(()=>g.clone().multiplyScalar(S?m:-m),[g,m,S]),I=e(()=>g.clone().multiplyScalar(S?s:-s),[g,s,S]),[j,x]=e(()=>[h.clone().add(w),b.clone().sub(I)],[h,b,w,I]),[z,C]=e(()=>S?[f.clone().sub(y),f.clone().add(y)]:[j.clone().add(w),x.clone().sub(I)],[j,x,w,I,f,y,S]);return{indicatorCenter:f,startArrowTip:h,startArrowBase:j,startLine:z,endArrowTip:b,endArrowBase:x,endLine:C,showIndicatorLine:e(()=>S||u,[S,u])}};

package/dist/configurator/scene/scene-entity/dimension-indicators/use-offset-indicator.d.ts

@@ -0,0 +1,74 @@
+import { Matrix4, Vector3 } from 'three';
+import type { ComponentReader, ComponentSnapshot, DimensionUnit, DomainEntity, DomainEntityId, DomainState, OffsetAnchorsComponent, PositionProjections } from '#package/domain';
+import { type OffsetIndicatorResult } from './offset-indicator-matching.js';
+/**
+ * React hook that computes the offset indicator for an entity.
+ *
+ * Finds the closest reference entity along a direction vector and returns the anchor pair
+ * + projection needed to render the indicator, or null if no valid reference is found.
+ *
+ * All data is read inside a single `useRenderedSelector` callback via `componentReader`
+ * and `positionProjections`, delegating the core algorithm to pure functions in
+ * `offset-indicator-matching.ts`.
+ *
+ * All calculations happen in this entity's **parent world space**.
+ *
+ * 1. Resolve direction vector in parent world space (from `directionVectorRelativeToEntityId`
+ *    space if specified, otherwise used as-is).
+ * 2. Transform all anchors from entity-local → parent world space.
+ * 3. `findBestAnchorPairs`: per reference entity, find the closest anchor pair by projected
+ *    distance (O(N×M)), sort candidates.
+ * 4. `findWinningCandidate`: walk candidates with perpendicular hull checks (convex hull +
+ *    SAT) and minDistance logic.
+ * 5. Compute extrusion vector in entity-local space (stays inline — branches on
+ *    `directionVectorRelativeToEntityId`).
+ * 6. `computeIndicatorGeometry`: convert winning pair to entity-local space for rendering.
+ */
+export interface UseOffsetIndicatorProps {
+    readonly entityId: DomainEntityId<string>;
+    /**
+     * `offsetAnchors` instance names to read on the positioned entity itself.
+     * These supply the start points of the measurement.
+     */
+    readonly targetEntityOffsetAnchors: readonly string[];
+    /**
+     * `offsetAnchors` instance names to read on the reference entities.
+     * These supply the end points of the measurement. Pass the same value as
+     * `targetEntityOffsetAnchors` to use one shared anchor pool on both sides.
+     */
+    readonly targetReferenceOffsetAnchors: readonly string[];
+    readonly referenceEntityIds?: ReadonlyArray<DomainEntityId<string>> | null;
+    readonly directionVector: {
+        readonly x?: number;
+        readonly y?: number;
+        readonly z?: number;
+    };
+    readonly directionVectorRelativeToEntityId?: DomainEntityId<string> | null;
+    readonly maxDistance?: number | null;
+    readonly minDistance?: number | null;
+    readonly maxPerpendicularDistance?: number | null;
+    readonly minPerpendicularDistance?: number | null;
+    readonly extrusionX?: number;
+    readonly extrusionY?: number;
+    readonly extrusionZ?: number;
+}
+export declare const useOffsetIndicator: (props: UseOffsetIndicatorProps) => OffsetIndicatorResult | null;
+interface AnchorWithOrigin {
+    readonly componentSnapshot: ComponentSnapshot<OffsetAnchorsComponent>;
+    readonly position: Vector3;
+}
+export declare const readAndResolveOffsetAnchors: (props: {
+    componentReader: ComponentReader<DomainEntity<string>>;
+    entityId: DomainEntityId<string>;
+    referenceEntityIds: ReadonlyArray<DomainEntityId<string>> | null;
+    targetEntityOffsetAnchors: readonly string[];
+    targetReferenceOffsetAnchors: readonly string[];
+    state: DomainState<DomainEntity<string>>;
+    positionProjections: PositionProjections<DomainEntity<string>>;
+    distanceDataUnit: DimensionUnit;
+}) => {
+    thisAnchors: AnchorWithOrigin[];
+    refAnchorsByEntity: Map<DomainEntityId<string>, AnchorWithOrigin[]>;
+    entityWorldMatrix: Matrix4;
+} | null;
+export {};

package/dist/configurator/scene/scene-entity/dimension-indicators/use-offset-indicator.js

@@ -0,0 +1 @@
+import{Matrix4 as e,Vector3 as t}from"three";import{DEFAULT_DIMENSION_UNIT as n,DIMENSION_EPSILON as r,dimensionUnitsCoefficient as i,isDomainEntityId as o,isVirtualEntityId as a,offsetAnchorsComponent as s}from"#package/domain";import{useDimensionConfig as c,useDomain as l,useLogger as d,useRenderedSelector as f}from"#package/react-sdk";import{computeIndicatorGeometry as p,findBestAnchorPairs as y,findWinningCandidate as u}from"./offset-indicator-matching.js";export const useOffsetIndicator=o=>{let a=d(),{componentReader:s,positionProjections:m}=l(),{distanceDataUnit:x}=c();return f(c=>{let l=i(x,n),d=i(n,x),f=readAndResolveOffsetAnchors({componentReader:s,entityId:o.entityId,referenceEntityIds:o.referenceEntityIds??null,targetEntityOffsetAnchors:o.targetEntityOffsetAnchors,targetReferenceOffsetAnchors:o.targetReferenceOffsetAnchors,state:c.state,positionProjections:m,distanceDataUnit:x});if(!f)return null;let{thisAnchors:I,refAnchorsByEntity:g}=f,h=m.getEntityParentWorldMatrix(o.entityId,c.state,null),R=h.clone().invert(),D=I.map(e=>e.position.applyMatrix4(R)),E=new Map;for(let[e,t]of g)E.set(e,t.map(e=>e.position.applyMatrix4(R)));let M=m.getEntityWorldMatrix(o.entityId,c.state,null),A=m.getLocalEntityMatrix(o.entityId,c.state,null),P=o.directionVectorRelativeToEntityId?m.getEntityWorldMatrix(o.directionVectorRelativeToEntityId,c.state,null):null,w=new t(o.directionVector.x??0,o.directionVector.y??0,o.directionVector.z??0);if(w.lengthSq()<r)return a.error(`offsetIndicator on entity "${o.entityId}": directionVector is zero or near-zero. Set a non-zero directionVector (e.g. { x: 1 }) in the offsetIndicator component YAML specs.`),null;let O=w.clone();if(P){let t=new e().extractRotation(P);O.applyMatrix4(t);let n=new e().extractRotation(h).invert();O.applyMatrix4(n)}O.normalize();let Y=null==o.maxDistance?o.maxDistance:o.maxDistance*l,X=null==o.minDistance?o.minDistance:o.minDistance*l,Z=null==o.maxPerpendicularDistance?o.maxPerpendicularDistance:o.maxPerpendicularDistance*l,V=null==o.minPerpendicularDistance?o.minPerpendicularDistance:o.minPerpendicularDistance*l,v=u(y(D,E,O,Y),D,E,O,{minDistance:X,maxPerpendicularDistance:Z,minPerpendicularDistance:V});if(!v)return null;let z=new t((o.extrusionX??0)*l,(o.extrusionY??0)*l,(o.extrusionZ??0)*l);if(P){let t=new e().extractRotation(P);z.applyMatrix4(t);let n=new e().extractRotation(M).invert();z.applyMatrix4(n)}else{let t=new e().extractRotation(A).invert();z.applyMatrix4(t)}let j=p(v.bestStart,v.bestEndRef,v.bestProjectedDist,O,M,h,z);return{startX:j.startX*d,startY:j.startY*d,startZ:j.startZ*d,endX:j.endX*d,endY:j.endY*d,endZ:j.endZ*d,endReferenceX:j.endReferenceX*d,endReferenceY:j.endReferenceY*d,endReferenceZ:j.endReferenceZ*d,extrusionX:j.extrusionX*d,extrusionY:j.extrusionY*d,extrusionZ:j.extrusionZ*d,signedProjectedDistance:j.signedProjectedDistance*d,directionX:j.directionX,directionY:j.directionY,directionZ:j.directionZ}},[s,o.entityId,o.referenceEntityIds,o.targetEntityOffsetAnchors,o.targetReferenceOffsetAnchors,o.directionVectorRelativeToEntityId,m,a,o.minDistance,o.maxDistance,o.maxPerpendicularDistance,o.minPerpendicularDistance,o.extrusionX,o.extrusionY,o.extrusionZ,o.directionVector.x,o.directionVector.y,o.directionVector.z,x])};export const readAndResolveOffsetAnchors=e=>{let r=i(e.distanceDataUnit,n),{thisEntityAnchorsComponents:c,refEntityAnchorsComponents:l}=(e=>{let{componentReader:t,entityId:n,referenceEntityIds:r,targetEntityOffsetAnchors:i,targetReferenceOffsetAnchors:o,state:a}=e;return{thisEntityAnchorsComponents:t.readManyComponents({entityIds:[n],componentTypes:[s],instanceNames:i},a),refEntityAnchorsComponents:t.readManyComponents({entityIds:r??void 0,componentTypes:[s],instanceNames:o},a).filter(e=>e.componentInstance.entityId!==n)}})({componentReader:e.componentReader,entityId:e.entityId,referenceEntityIds:e.referenceEntityIds??null,targetEntityOffsetAnchors:e.targetEntityOffsetAnchors,targetReferenceOffsetAnchors:e.targetReferenceOffsetAnchors,state:e.state});if(0===c.length||0===l.length)return null;let d=new Set(l.map(e=>e.componentInstance.entityId).filter(o));d.delete(e.entityId);let f=e.positionProjections.getEntityWorldMatrix(e.entityId,e.state,null),p=new Map;for(let t of d){let n=e.positionProjections.getEntityWorldMatrix(t,e.state,null);p.set(t,n)}let y=c.flatMap(e=>e.state.anchors.map(n=>{let i=new t((n.x??0)*r,(n.y??0)*r,(n.z??0)*r);return i.applyMatrix4(f),{componentSnapshot:e,position:i}})),u=new Map;for(let e of l){let n=e.componentInstance.entityId;if(a(n))continue;let i=p.get(n);if(!i)continue;let o=u.get(n);for(let a of(o||(o=[],u.set(n,o)),e.state.anchors)){let n=new t((a.x??0)*r,(a.y??0)*r,(a.z??0)*r);n.applyMatrix4(i),o.push({componentSnapshot:e,position:n})}}return{thisAnchors:y,refAnchorsByEntity:u,entityWorldMatrix:f}};

package/dist/configurator/scene/scene-entity/drag-and-drop/SceneEntityRotationWidget.d.ts

@@ -0,0 +1,15 @@
+import { type Object3D } from 'three';
+import { type DomainEntityId, type RotatableSurface } from '#package/domain';
+interface SceneEntityRotationWidgetProps {
+    readonly id: DomainEntityId<string>;
+    readonly parent: Object3D;
+    readonly surface: RotatableSurface;
+    readonly target: string;
+    readonly outerRadius: number;
+    readonly innerRadius: number;
+    readonly color?: string;
+    readonly angleColor?: string;
+    readonly hideAngleInput?: boolean;
+}
+export declare const SceneEntityRotationWidget: import("react").MemoExoticComponent<(props: SceneEntityRotationWidgetProps) => import("react/jsx-runtime").JSX.Element | null>;
+export {};

package/dist/configurator/scene/scene-entity/drag-and-drop/SceneEntityRotationWidget.js

@@ -0,0 +1 @@
+import{jsx as t,jsxs as r,Fragment as e}from"react/jsx-runtime";import{memo as o,useEffect as a,useMemo as i,useRef as n}from"react";import{Vector3 as s}from"three";import{AngleUnit as l,convertAngleUnits as m,rotatableComponent as c}from"#package/domain";import{useEagerObservableValue as d,useFirstRenderedComponent as h}from"#package/react-sdk";import{useConfigurator as p}from"../../../application-runtime/index.js";import{SceneHtml as g}from"../../scene-html/index.js";import{useRotateHandle as F}from"./use-rotate-handle.js";let f=o(o=>{let{id:c,parent:h,surface:f,target:u,outerRadius:y,innerRadius:x,color:M,angleColor:I,hideAngleInput:j,rotation:P}=o,S=n(null),{dragAndDropSystem:T}=p(),b=F({entityId:c,parent:h,surface:f,target:u}),k=d(T.draggingState$),{position:z}=i(()=>{let{normal:t,constant:r}=f;return{position:new s(t.x,t.y,t.z).normalize().clone().multiplyScalar(-r)}},[f]);a(()=>{S.current?.traverse(t=>{t.layers.enable(1)})},[]);let{indicatorThetaStart:w,indicatorThetaLength:B}=i(()=>P<0?{indicatorThetaStart:P,indicatorThetaLength:-P}:{indicatorThetaStart:0,indicatorThetaLength:P},[P]);return r("group",{position:z,...b,ref:S,name:"rotation-widget",children:[r("mesh",{"rotation-x":Math.PI/2,children:[t("ringGeometry",{args:[y,x,64,1]}),t("meshBasicMaterial",{color:M??"#00FF00"})]}),k?.type==="rotation"&&r(e,{children:[r("mesh",{"position-y":1,"rotation-x":Math.PI/2,"rotation-z":Math.PI/2,children:[t("ringGeometry",{args:[y,x,64,1,w,B]}),t("meshBasicMaterial",{color:I??"#FF0000"})]}),r("mesh",{"rotation-x":Math.PI/2,"rotation-z":Math.PI/2,children:[t("ringGeometry",{args:[x,0,64,1,w,B]}),t("meshBasicMaterial",{color:"#FFFFFF",transparent:!0,opacity:.6})]})]}),!j&&t(g,{offsetX:0,offsetY:0,offsetZ:1.3*x,entityId:c,children:r("div",{style:{backgroundColor:"white",color:"#3F3F3F",padding:"4px",border:"1px solid #3F3F3F",borderRadius:"4px"},children:[Math.round(m(P,l.radian,l.degree)),"\xb0"]})})]})});export const SceneEntityRotationWidget=o(r=>{let{target:e}=r,o=h({instanceNames:[e],componentTypes:[c]});return o?t(f,{...r,rotation:o.state.rotation}):null});

package/dist/configurator/scene/scene-entity/drag-and-drop/SceneEntityRotationWidgets.d.ts

@@ -0,0 +1,9 @@
+import { type Object3D } from 'three';
+import { type DomainEntityId } from '#package/domain';
+interface Props {
+    id: DomainEntityId<string>;
+    parent: Object3D;
+}
+declare const SceneEntityRotationWidgetsComponent: (props: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const SceneEntityRotationWidgets: import("react").MemoExoticComponent<typeof SceneEntityRotationWidgetsComponent>;
+export {};

package/dist/configurator/scene/scene-entity/drag-and-drop/SceneEntityRotationWidgets.js

@@ -0,0 +1 @@
+import{jsx as t,Fragment as e}from"react/jsx-runtime";import{memo as a}from"react";import{rotationHandleComponent as n}from"#package/domain";import{useComponents as r}from"#package/react-sdk";import{SceneEntityRotationWidget as o}from"./SceneEntityRotationWidget.js";export const SceneEntityRotationWidgets=a(a=>{let{id:i,parent:s}=a;return t(e,{children:r({entityIds:[i],componentTypes:[n]}).map(e=>t(o,{id:i,parent:s,surface:e.state.surface,target:e.state.target,outerRadius:e.state.outerRadius,innerRadius:e.state.innerRadius,color:e.state.color,angleColor:e.state.angleColor,hideAngleInput:e.state.hideAngleInput},e.componentInstance.instanceName))})});

package/dist/configurator/scene/scene-entity/drag-and-drop/create-entity-shadow.d.ts

@@ -0,0 +1,2 @@
+import type { Object3D } from 'three';
+export declare const createEntityShadow: (object: Object3D) => Object3D<import("three").Object3DEventMap>;

package/dist/configurator/scene/scene-entity/drag-and-drop/create-entity-shadow.js

@@ -0,0 +1 @@
+import{createTranslucentClone as t}from"./create-translucent-clone.js";export const createEntityShadow=e=>t(e,{opacity:.5,emissive:{color:"#808080",intensity:3}});

package/dist/configurator/scene/scene-entity/drag-and-drop/create-translucent-clone.d.ts

@@ -0,0 +1,18 @@
+import { type Object3D } from 'three';
+interface TranslucentCloneOptions {
+    readonly opacity: number;
+    /** When set, adds an emissive tint to MeshStandardMaterial clones. */
+    readonly emissive?: {
+        readonly color: string;
+        readonly intensity: number;
+    };
+    /** When true, adds polygonOffset to prevent Z-fighting with overlapping geometry. */
+    readonly polygonOffset?: boolean;
+}
+/**
+ * Clone an Object3D hierarchy and make all materials translucent.
+ * Used for both the drag shadow (emissive gray tint) and the snap
+ * auto-rotate preview ghost (polygonOffset, no tint).
+ */
+export declare const createTranslucentClone: (object: Object3D, options: TranslucentCloneOptions) => Object3D;
+export {};

package/dist/configurator/scene/scene-entity/drag-and-drop/create-translucent-clone.js

@@ -0,0 +1 @@
+import{Color as e,Material as t,MeshBasicMaterial as i,MeshStandardMaterial as a}from"three";export const createTranslucentClone=(e,i)=>{let a=e.clone();return a.traverse(e=>{if("material"in e&&null!=e.material)if(Array.isArray(e.material))for(let t=0;t<e.material.length;t++)e.material[t]=n(e.material[t],i);else e.material instanceof t&&(e.material=n(e.material,i))}),a};let n=(t,n)=>{let r=t.clone();return(r instanceof a||r instanceof i)&&(r.opacity=n.opacity,r.transparent=!0,r.depthWrite=!1,n.polygonOffset&&(r.polygonOffset=!0,r.polygonOffsetFactor=-1,r.polygonOffsetUnits=-1)),n.emissive&&r instanceof a&&(r.emissive=new e(n.emissive.color),r.emissiveIntensity=n.emissive.intensity),r};

package/dist/configurator/scene/scene-entity/drag-and-drop/entity-intersections.d.ts

@@ -0,0 +1,48 @@
+import type { Intersection } from '@react-three/fiber';
+import { type Object3D } from 'three';
+import { type DomainEntityId, type EntityId } from '#package/domain';
+export type EntityRoot3DUserData = {
+    type: 'entityRoot';
+    entityId: EntityId;
+};
+export type EntityObject3DUserData = {
+    type: 'entityObject';
+    entityId: EntityId;
+    objectInstanceName: string;
+};
+/**
+ * Marks a `sceneEntityControl` subtree in the scene graph. `includeInCameraFit`
+ * lets a control opt into the camera fit traversal (bounding box and sphere).
+ * Controls are excluded by default, so they can live in the entity tree without
+ * inflating fit targets.
+ */
+export type SceneEntityControl3DUserData = {
+    type: 'sceneEntityControl';
+    includeInCameraFit: boolean;
+};
+/**
+ * Marks a `sceneEntityObjectGroup` `<group>` node so scene-graph lookups can descend through the
+ * object hierarchy. Groups are intermediate transform nodes between the entity root and its objects;
+ * traversals skip past them rather than treating them as objects.
+ */
+export type EntityObjectGroup3DUserData = {
+    type: 'entityObjectGroup';
+    entityId: EntityId;
+    groupInstanceName: string;
+};
+export type Entity3DUserData = EntityRoot3DUserData | EntityObject3DUserData | SceneEntityControl3DUserData | EntityObjectGroup3DUserData;
+export declare const isIncludedInCameraFit: (object: Object3D) => boolean;
+/**
+ * Augment type declaration to include entityId in the intersected object userData.
+ */
+declare module '@react-three/fiber' {
+    interface Intersection extends THREE.Intersection {
+        /** The event source (the object which registered the handler) */
+        eventObject: THREE.Object3D;
+        /** We add the entityId to relevant objects in the scene */
+        object: THREE.Object3D & {
+            userData: Entity3DUserData;
+        };
+    }
+}
+export declare const getFirstIntersectedEntityId: (intersections: Intersection[]) => DomainEntityId<string> | null;

package/dist/configurator/scene/scene-entity/drag-and-drop/entity-intersections.js

@@ -0,0 +1 @@
+export const isIncludedInCameraFit=t=>{let e=t.userData;return"sceneEntityControl"!==e.type||!0===e.includeInCameraFit};export const getFirstIntersectedEntityId=t=>{let e=t[0]?.object??null;for(;null!=e;){let t=e.userData;if("entityRoot"===t.type)return t.entityId;let n=e.parent;null==n&&(e=null),e=n}return null};