@buerli.io/react-cad 0.13.0 → 0.13.1-beta.10

package/build/plugins/Dimensions/utils.d.ts

@@ -1,5 +1,5 @@
-import { DrawingID, ObjectID, IStructureObject } from '@buerli.io/core';
+import { DrawingID, ObjectID, ScgObject } from '@buerli.io/core';
 export declare function useDimensionSetId(drawingId: DrawingID, ownerId: ObjectID): ObjectID | undefined;
-export declare const isAngular: (dim: IStructureObject) => boolean;
-export declare const isRadial: (dim: IStructureObject) => boolean;
-export declare const isDiameter: (dim: IStructureObject) => boolean;
+export declare const isAngular: (dim: ScgObject) => boolean;
+export declare const isRadial: (dim: ScgObject) => boolean;
+export declare const isDiameter: (dim: ScgObject) => boolean;

package/build/plugins/Expressions/useContextMenuItems.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import 'antd/dist/antd.css';
+import { DrawingID, ObjectID } from '@buerli.io/core';
+import { MenuElement } from '../../components/UI/CAD/common/ContextMenu';
+export declare function useContextMenuItems(drawingId: DrawingID, productId: ObjectID, setEditName: React.Dispatch<React.SetStateAction<boolean>>): MenuElement[];

package/build/plugins/HLConstraints/components/LimitedValue.d.ts

@@ -5,7 +5,7 @@ export declare const LimitedValue: React.FC<{
     objId: ObjectID;
     memberName: string;
     limitsName?: string;
-    onUpdate: (value: number | string) => Promise<void>;
+    onUpdate: (value: number | string) => Promise<any>;
     caption?: string;
     angle?: boolean;
     disabled?: boolean;

package/build/plugins/HLConstraints/components/Limits.d.ts

@@ -1,12 +1,15 @@
 import React from 'react';
 import { DrawingID, ObjectID } from '@buerli.io/core';
-import { LimitsParam } from '@buerli.io/classcad';
 import { MemberParam } from '../../../types';
 export declare enum LimitsDiplayType {
     MIN = 0,
     MAX = 1,
     MINMAX = 2
 }
+export declare type LimitsParam<T = string | number> = {
+    min: T | null;
+    max: T | null;
+};
 export declare function useLimitsParam(drawingId: DrawingID, objId: ObjectID, memberName: string, options?: {
     angle?: boolean;
     forceNoLimits?: boolean;
@@ -15,6 +18,8 @@ export declare const Limits: React.FC<{
     param: MemberParam<LimitsParam>;
     displayType?: LimitsDiplayType;
     onUpdate?: any;
+    iconMinURL?: string;
+    iconMaxURL?: string;
     caption?: string;
     validator?: (numParam: LimitsParam, pName?: string) => string[];
 }>;

package/build/plugins/HLConstraints/validators.d.ts

@@ -1,2 +1,2 @@
-import { LimitsParam } from '@buerli.io/classcad';
+import { LimitsParam } from "./components/Limits";
 export declare function validateLimits(limits: LimitsParam, name: string): string[];

package/build/plugins/Sketch/Root/Constraints/constraintsHelpers.d.ts

@@ -1,16 +1,18 @@
-import { IStructureObject, IStructureTree, ObjectID } from '@buerli.io/core';
+import { ScgObject, ScgTree, ObjectID } from '@buerli.io/core';
+import { ScgClassType } from '@buerli.io/classcad';
 declare type GeometryChecker = {
     type: string;
-    check: (object: IStructureObject) => number | number[];
+    check: (object: ScgObject) => number | number[];
 };
 declare type ConstraintGeometryCombination = {
     entityAdapter: (entities: ObjectID[]) => ObjectID[][];
     input: GeometryChecker[];
 };
-declare function createHelper(type: string, name: string, ...constraintGeometryCombinations: ConstraintGeometryCombination[]): {
+declare function createHelper(objClass: ScgClassType, type: string, name: string, ...constraintGeometryCombinations: ConstraintGeometryCombination[]): {
+    objClass: ScgClassType;
     type: string;
     name: string;
-    adapt(entities: ObjectID[], tree: IStructureTree): number[][] | undefined;
+    adapt(entities: ObjectID[], tree: ScgTree): number[][] | undefined;
     getTooltip(): string[];
 };
 export declare const constraintsHelpers: {

package/build/plugins/Sketch/Root/Constraints/utils.d.ts

@@ -1,6 +1,6 @@
-import { CCClasses } from '@buerli.io/classcad';
+import { ScgClassType } from '@buerli.io/classcad';
 export declare const classNameMap: {
     [key: string]: string;
 };
-export declare function getKeyCode(constrClass: CCClasses): "KeyF" | "KeyH" | "KeyV" | "KeyI" | "KeyT" | "KeyP" | "KeyC" | "KeyE" | "KeyO" | "KeyD" | "KeyR" | null | undefined;
-export declare function getHotKey(constrClass: CCClasses): string;
+export declare function getKeyCode(constrClass: ScgClassType): "KeyF" | "KeyH" | "KeyV" | "KeyI" | "KeyT" | "KeyP" | "KeyC" | "KeyE" | "KeyO" | "KeyD" | "KeyR" | null | undefined;
+export declare function getHotKey(constrClass: ScgClassType): string;

package/build/plugins/Sketch/Root/CopyPatterns.d.ts

@@ -1,7 +1,2 @@
 import React from 'react';
-export declare enum Patterns {
-    RECTANGULAR = "RECTANGULAR",
-    CIRCULAR = "CIRCULAR",
-    MIRROR = "MIRROR"
-}
 export declare const CopyPatterns: React.FC;

package/build/plugins/Sketch/Root/SketchGroup.d.ts

@@ -4,5 +4,6 @@ export declare const SketchGroup: React.FC<{
     helpUrl?: string | URL;
     collapse?: boolean;
     postfix?: React.ReactNode;
+    info?: React.ReactNode;
     children?: React.ReactNode;
 }>;

package/build/plugins/Sketch/View/graphics/TmpAngularDimension.d.ts

@@ -1,7 +1,5 @@
 import * as THREE from 'three';
 import React from 'react';
-export declare const calcSector: (dimPos: THREE.Vector3, dir0: THREE.Vector3, dir1: THREE.Vector3, center: THREE.Vector3) => 0 | 1 | 2 | 3;
-export declare const calcPreviewValue: (dir0: THREE.Vector3, dir1: THREE.Vector3, sector: number, reflex: number) => number;
 export declare const TmpPositionHandler: React.FC<{
     position: THREE.Vector3;
 }>;

package/build/plugins/Sketch/View/graphics/hooks.d.ts

@@ -1,10 +1,11 @@
-import { IStructureObject, DrawingID, ObjectID } from '@buerli.io/core';
+import { ScgObject, DrawingID, ObjectID } from '@buerli.io/core';
 export declare const useGeomParams: (objId: ObjectID) => {
     renderOrder: number;
     polygonOffsetUnits: number;
     isHovered: boolean;
     isSelected: boolean;
     isHighlighted: boolean;
+    isConstrOverdefined: boolean;
 };
 declare type ObjState = {
     isSketchActive: boolean;
@@ -12,9 +13,10 @@ declare type ObjState = {
     isGHovered: boolean;
     isSHovered: boolean;
     isSelected: boolean;
+    isConstrOverdefined: boolean;
     lgsState: number;
 };
-export declare const getColor: (object: IStructureObject, objState: ObjState) => number;
+export declare const getColor: (object: ScgObject, objState: ObjState) => number;
 /**
  * Return pointerHandlers of currently enabled sketch Handler.
  * @param objId

package/build/plugins/Sketch/View/graphics/primitives.d.ts

@@ -18,20 +18,6 @@ export declare const Point: React.FC<{
     position: THREE.Vector3;
     size?: number;
 } & commonProps>;
-export declare function getArcAngles(params: {
-    start: THREE.Vector3;
-    end: THREE.Vector3;
-    center: THREE.Vector3;
-    clockwise: boolean;
-    radius: number;
-}): {
-    center: THREE.Vector3;
-    mid: THREE.Vector3;
-    radius: number;
-    startAngle: number;
-    endAngle: number;
-    bulge: number;
-};
 export declare const Arc: React.FC<{
     start: THREE.Vector3;
     end: THREE.Vector3;

package/build/plugins/Sketch/View/handlers/HandlersConstructors.d.ts

@@ -7,7 +7,6 @@ import { DrawCircle } from './DrawCircle';
 import { Fillet } from './Fillet';
 import { Trim } from './Trim';
 import { Split } from './Split';
-import { UseRef } from './UseRef';
 import { SSelect } from './SSelect';
 export declare const HandlersConstructors: {
     createAngle: typeof CreateAngle;
@@ -19,7 +18,8 @@ export declare const HandlersConstructors: {
     fillet: typeof Fillet;
     trim: typeof Trim;
     split: typeof Split;
-    useReference: typeof UseRef;
+    useGeometry: (drawingId: DrawingID, pluginId: PluginID) => import("../../types").Handler;
+    useReference: (drawingId: DrawingID, pluginId: PluginID) => import("../../types").Handler;
     drawRect2Points: (drawingId: DrawingID, pluginId: PluginID) => import("../../types").Handler;
     drawRectCenter: (drawingId: DrawingID, pluginId: PluginID) => import("../../types").Handler;
     drawArcCenter: (drawingId: DrawingID, pluginId: PluginID) => import("../../types").Handler;

package/build/plugins/Sketch/View/handlers/Use.d.ts

@@ -0,0 +1,3 @@
+import { DrawingID, PluginID } from '@buerli.io/core';
+import { HandlersList, Handler } from '../../types';
+export declare function Use(drawingId: DrawingID, pluginId: PluginID, useType: HandlersList.USEGEOM | HandlersList.USEREF): Handler;

package/build/plugins/Sketch/View/handlers/filletHelpers.d.ts

@@ -1,42 +1,22 @@
 import * as THREE from 'three';
-import { IStructureTree, ObjectID, IStructureObject } from '@buerli.io/core';
-export declare function getSketchDescendants(tree: IStructureTree, sketchId: ObjectID): number[];
-export declare function findPointsAt(pos: THREE.Vector3, tree: IStructureTree, sketchId: ObjectID): IStructureObject[];
-export declare function findConstraints(type: string, objA: IStructureObject, objB: IStructureObject, tree: IStructureTree, sketchId: ObjectID): number[];
-declare type FilletInfo = {
-    lines: Array<IStructureObject>;
-    lineStarts: Array<IStructureObject>;
-    lineEnds: Array<IStructureObject>;
-    control: THREE.Vector3;
-};
-declare type NewFilletInfo = FilletInfo & {
-    incidence: ObjectID;
+import { ObjectID, DrawingID } from '@buerli.io/core';
+export declare type FilletablePointInfo = {
+    offset: number;
+    arcStartPos: THREE.Vector3;
+    arcEndPos: THREE.Vector3;
+    arcCenterPos: THREE.Vector3;
+    clockwise: boolean;
+    lineIds: ObjectID[];
 };
-declare type ExistingFilletInfo = FilletInfo & {
-    object: IStructureObject;
-    objectEnds: IStructureObject[];
-    filletPoint: IStructureObject;
+export declare type FilletArcsInfo = {
+    controlPos: THREE.Vector3;
+    arcStartPos: THREE.Vector3;
+    arcEndPos: THREE.Vector3;
 };
-export declare function recognizeFilletableAngle(pos: THREE.Vector3, tree: IStructureTree, sketchId: ObjectID): NewFilletInfo | null;
-export declare function getTouchPoints(info: FilletInfo, distance: number): THREE.Vector3[] | null;
-export declare function calculateCenterPoint(start: THREE.Vector3, end: THREE.Vector3, control: THREE.Vector3): THREE.Vector3;
 export declare function evaluateClockwise(start: THREE.Vector3, end: THREE.Vector3, control: THREE.Vector3): boolean;
-export declare function calculateFilletParams(info: FilletInfo, distance: number): {
-    start: THREE.Vector3;
-    end: THREE.Vector3;
-    center: THREE.Vector3;
-    clockwise: boolean;
-    control: THREE.Vector3;
-} | null;
-export declare function calculateNewFilletData(object: IStructureObject, tree: IStructureTree, sketchId: ObjectID): {
-    info: NewFilletInfo;
-    params: {
-        start: THREE.Vector3;
-        end: THREE.Vector3;
-        center: THREE.Vector3;
-        clockwise: boolean;
-        control: THREE.Vector3;
-    };
-} | null;
-export declare function recognizeFilletByArc(object: IStructureObject, tree: IStructureTree, sketchId: ObjectID): ExistingFilletInfo | null;
-export {};
+export declare const getFilletablePointsMap: (drawingId: DrawingID, sketchId: ObjectID) => {
+    [key: number]: FilletablePointInfo;
+};
+export declare const getFilletArcsMap: (drawingId: DrawingID, sketchId: ObjectID) => {
+    [key: number]: FilletArcsInfo;
+};

package/build/plugins/Sketch/View/handlers/hoverHelpers.d.ts

@@ -0,0 +1,3 @@
+import * as THREE from 'three';
+import { DrawingID, PluginID } from '@buerli.io/core';
+export declare const hoverIntersections: (drawingId: DrawingID, pluginId: PluginID, intersections: THREE.Intersection[]) => void;

package/build/plugins/Sketch/View/handlers/splitHelpers.d.ts

@@ -1,34 +1,19 @@
 import * as THREE from 'three';
-import { DrawingID, ObjectID } from "@buerli.io/core";
-import { CCClasses } from "@buerli.io/classcad";
+import { DrawingID, ObjectID } from '@buerli.io/core';
+import { ScgClassType } from '@buerli.io/classcad';
+import { CCArcInfo, CCCircleInfo, CCLineInfo } from '../../../../utils/sketchIntersectionUtils';
 declare type CommonInfo = {
-    class: CCClasses.CCLine | CCClasses.CCArc | CCClasses.CCCircle;
+    class: ScgClassType.CCLine | ScgClassType.CCArc | ScgClassType.CCCircle;
     bb: THREE.Box2;
+    isSplittable: boolean;
 };
-declare type LineInfo = CommonInfo & {
-    start: THREE.Vector3;
-    end: THREE.Vector3;
-    dir: THREE.Vector3;
-};
-declare type ArcInfo = CommonInfo & {
-    start: THREE.Vector3;
-    end: THREE.Vector3;
-    center: THREE.Vector3;
-    radius: number;
-    clockwise: boolean;
-    startAngle: number;
-    endAngle: number;
-    angularlength: number;
-};
-declare type CircleInfo = CommonInfo & {
-    center: THREE.Vector3;
-    radius: number;
-};
-export declare type ObjInfo = LineInfo | ArcInfo | CircleInfo;
-export declare function getSketchObjInfo(drawingId: DrawingID, objId: ObjectID): LineInfo | CircleInfo | undefined;
-export declare function getNormalizedPosition(point: THREE.Vector3, sketchObject: ObjInfo): number;
-export declare function getParameterizedPosition(t: number, sketchObject: ObjInfo): THREE.Vector3;
-export declare function calculateIntersections(object: ObjInfo, sketchObjects: ObjInfo[]): number[];
-export declare function calculateClosestIntersection(point: THREE.Vector3, object1: ObjInfo, object2: ObjInfo): number[][];
-export declare function getClosestPoint(point: THREE.Vector3, sketchObject: ObjInfo): THREE.Vector3;
+declare type CCLineInfoE = CommonInfo & CCLineInfo;
+declare type CCArcInfoE = CommonInfo & CCArcInfo;
+declare type CCCircleInfoE = CommonInfo & CCCircleInfo;
+export declare type SketchObjInfoE = CCLineInfoE | CCArcInfoE | CCCircleInfoE;
+export declare function getSketchObjInfo(drawingId: DrawingID, objId: ObjectID, unsplittableIds: ObjectID[]): CCLineInfoE | CCCircleInfoE | undefined;
+export declare function getRigidsetEntityIds(drawingId: DrawingID, sketchId: ObjectID): number[];
+export declare function calculateIntersections(object: SketchObjInfoE, sketchObjects: SketchObjInfoE[]): number[];
+export declare function calculateClosestIntersection(point: THREE.Vector3, object1: SketchObjInfoE, object2: SketchObjInfoE): number[][];
+export declare function getClosestPoint(point: THREE.Vector3, sketchObject: SketchObjInfoE): THREE.Vector3;
 export {};

package/build/plugins/Sketch/types.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="react" />
 import { ThreeEvent, ReactThreeFiber } from '@react-three/fiber';
-import { IStructureObject, ObjectID } from '@buerli.io/core';
+import { ScgObject, ObjectID } from '@buerli.io/core';
 import { InfinityPlane } from '../../components/graphics/InfinityPlane';
 import { Geometry } from 'three-stdlib';
 export declare type HighlightedConstraintsT = Array<{
@@ -29,15 +28,13 @@ export declare type SketchPState = {
             [key: ObjectID]: ObjectID;
         };
     };
+    overdefined: {
+        [key: ObjectID]: ObjectID[];
+    };
     isDragged: boolean;
     scale: number;
     step: number;
     mousePos: THREE.Vector3 | undefined;
-    drawnObjectsRef: React.MutableRefObject<THREE.Group> | undefined;
-    rubberBandRectangle: {
-        min: THREE.Vector2;
-        max: THREE.Vector2;
-    } | undefined;
     cursor: null | string;
     needsUpdate: number;
 };
@@ -57,6 +54,7 @@ export declare enum HandlersList {
     HOVER = "hover",
     TRIM = "trim",
     SPLIT = "split",
+    USEGEOM = "useGeometry",
     USEREF = "useReference",
     SSELECT = "sSelect"
 }
@@ -66,7 +64,7 @@ export declare type PointerEventsT = {
 };
 export declare type Handler = {
     name: HandlersList;
-    filter: (object: IStructureObject) => boolean;
+    filter: (object: ScgObject) => boolean;
     onActivate?: () => void;
     onDeactivate?: (() => void) | (() => Promise<void>);
     pointerHandlers: Record<string, (e: ThreeEvent<PointerEvent> & PointerEventsT) => void>;
@@ -121,6 +119,8 @@ export declare type TmpObject = TmpLineT | TmpPointT | TmpArcT | TmpCircleT | Tm
 export declare type TmpObjects = {
     [key: string]: TmpObject;
 };
+export declare type ConstraintType = 'COINCIDENT' | 'COLINEAR' | 'CONCENTRIC' | 'EQUAL_LENGTH' | 'EQUAL_RADIUS' | 'FIXATION' | 'HORIZONTAL' | 'MIDPOINT' | 'PARALLEL' | 'PERPENDICULAR' | 'SPLINE_FIT_POINT' | 'SYMMETRY' | 'TANGENT' | 'VERTICAL';
+export declare type DimensionType = 'RADIUS' | 'DIAMETER' | 'OFFSET' | 'HORIZONTAL_DISTANCE' | 'VERTICAL_DISTANCE' | 'ANGLE' | 'ANGLEOX';
 declare global {
     type InfinityPlaneT = ReactThreeFiber.Object3DNode<InfinityPlane, typeof InfinityPlane>;
     namespace JSX {

package/build/plugins/Sketch/utils/Interaction.d.ts

@@ -2,5 +2,6 @@ import * as THREE from 'three';
 import { DrawingID, PluginID, ObjectID } from '@buerli.io/core';
 export declare const hover: (drawingId: DrawingID, pluginId: PluginID, objIds: ObjectID[], hoverPos?: THREE.Vector3) => void;
 export declare const unhover: (drawingId: DrawingID, pluginId: PluginID, objId: ObjectID) => void;
-export declare const select: (drawingId: DrawingID, pluginId: PluginID, selectedId: ObjectID) => void;
+export declare const select: (drawingId: DrawingID, selectedId: ObjectID) => void;
+export declare const setSelected: (drawingId: DrawingID, selectedIds: ObjectID[]) => void;
 export declare const tab: (drawingId: DrawingID, pluginId: PluginID) => void;

package/build/plugins/Sketch/utils/OverdefinedStateManager.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { DrawingID, PluginID } from '@buerli.io/core';
+export declare const OverdefinedStateManager: React.FC<{
+    drawingId: DrawingID;
+    pluginId: PluginID;
+}>;

package/build/plugins/components/PluginForm.d.ts

@@ -15,7 +15,7 @@ import { MemberParam } from '../../types';
 export declare const PluginForm: React.FC<{
     drawingId: DrawingID;
     pluginId: PluginID;
-    update: () => Promise<void>;
+    update: () => Promise<any>;
     params: Record<string, MemberParam<any>>;
     children?: React.ReactNode;
     validator?: () => string[];

package/build/utils/conversionUtils.d.ts

@@ -0,0 +1,16 @@
+import { DrawingID, ObjectID } from "@buerli.io/core";
+import { MateParam } from "../components/UI/editors/RefsEditors";
+export declare const mateV1: (mateV0: MateParam) => {
+    flip: "X" | "-X" | "Y" | "-Y" | "Z" | "-Z";
+    reorient: "0" | "90" | "180" | "270";
+    path: number[] | undefined;
+    csys: number | undefined;
+};
+export declare const solidV1: (drawingId: DrawingID, id: ObjectID) => {
+    id: string | number;
+    indices?: number[] | undefined;
+};
+export declare const solidsV1: (drawingId: DrawingID, ids: ObjectID[]) => {
+    id: string | number;
+    indices?: number[] | undefined;
+}[];

package/build/utils/getHighlightedColor.d.ts

@@ -1 +1 @@
-export declare const getHighlightedColor: (isGHovered: boolean, isGSelected: boolean, isSHovered: boolean, isSSelected: boolean) => "green" | "red" | "#3280ff" | "#8040c0" | undefined;
+export declare const getHighlightedColor: (isGHovered: boolean, isGSelected: boolean, isSHovered: boolean, isSSelected: boolean) => "red" | "green" | "#3280ff" | "#8040c0" | undefined;

package/build/utils/helpers.d.ts

@@ -1,39 +1,18 @@
-import { CCClasses } from '@buerli.io/classcad';
-import { DrawingID, GeometryElement, GraphicID, IStructureObject, IStructureTree, MemberType, ObjectID, PointMem, PointMemValue, SelectedItem, ContainerGeometryT } from '@buerli.io/core';
+import { DrawingID, GeometryElement, GraphicID, ScgObject, MemberType, ObjectID, ScgPointMem, ScgPoint, ContainerGeometryT } from '@buerli.io/core';
 import * as THREE from 'three';
-export declare function membersValues(drawingId: DrawingID, ccObjId: DrawingID): any;
-export declare function addMembers(drawingId: DrawingID, ccObjId: DrawingID): {
-    members?: undefined;
-} | {
-    members: any;
-};
 export declare function useGlobalToLocalMatrix(drawingId: DrawingID, objId: ObjectID | undefined): THREE.Matrix4;
 export declare function getGlobalToLocalMatrix(drawingId: DrawingID, objId: ObjectID): THREE.Matrix4;
-export declare function setReference(index: number, state: any, set: any): (selected: SelectedItem[]) => void;
-export declare function convertToVector(point: PointMem | undefined): THREE.Vector3;
-export declare function convertToArray(point: PointMem): number[];
+export declare function convertToVector(point: ScgPointMem | undefined): THREE.Vector3;
+export declare function convertToArray(point: ScgPointMem): number[];
 export declare function linesIntersection(point1: THREE.Vector3, dir1: THREE.Vector3, point2: THREE.Vector3, dir2: THREE.Vector3): THREE.Vector3 | null;
 export declare const angleVecVec: (a: THREE.Vector3, b: THREE.Vector3) => number;
-export declare const calculateTangent: (tree: IStructureTree, object: IStructureObject, point: THREE.Vector3) => THREE.Vector3 | undefined;
-export declare function getDescendants(tree: IStructureTree, objectId: ObjectID): number[];
-export declare function getAncestorIdByClass(drawingId: DrawingID, objectId: ObjectID, parentClass: CCClasses): number | null;
-export declare const isSketchGeometry: (arg: IStructureObject | CCClasses) => boolean;
-export declare const is2DConstraint: (arg: IStructureObject | CCClasses) => boolean;
-export declare const isSketchRegion: (arg: IStructureObject | CCClasses) => boolean;
 export declare const degreesToRadians: (degrees: number) => number;
 export declare const radiansToDegrees: (radians: number) => number;
 export declare const getPointOnPlane: (unprojectedPoint: THREE.Vector3, camera: THREE.Camera, globalToLocalM: THREE.Matrix4) => THREE.Vector3;
 export declare const closestAngle: (value: number, to: number) => number;
-export declare const stringifyValue: (value: string | number | PointMemValue, type: MemberType) => string;
-export declare function findObject(drawingId: DrawingID, id: GraphicID | ObjectID, unrollRefs?: boolean): IStructureObject | ContainerGeometryT | GeometryElement | undefined;
-export declare function round(value: number, digits: number): number;
-export declare function rgbToHex(color: {
-    r: number;
-    g: number;
-    b: number;
-}): string;
+export declare const stringifyValue: (value: string | number | ScgPoint, type: MemberType) => string;
+export declare function findObject(drawingId: DrawingID, id: GraphicID | ObjectID, unrollRefs?: boolean): ScgObject | ContainerGeometryT | GeometryElement | undefined;
 export declare function fmod(num: number, denom: number): number;
-export declare function numberToHexColor(color: number): string;
 export declare const solveQuadratic: (a: number, b: number, c: number) => number[];
 export declare const solveQuartic: (a: number, b: number, c: number, d: number, e: number) => number[];
-export declare function getRegionCoordSys(drawingId: DrawingID, regionObj: IStructureObject): THREE.Vector3[];
+export declare function getRegionCoordSys(drawingId: DrawingID, regionObj: ScgObject): THREE.Vector3[];

package/build/utils/mateUtils.d.ts

@@ -1,4 +1,2 @@
 import { DrawingID, ObjectID } from '@buerli.io/core';
-export declare const getAncestors: (drawingId: DrawingID, objectId: ObjectID) => number[];
-export declare const getActiveReference: (drawingId: DrawingID, matePath: ObjectID[], activeRefs: ObjectID[]) => number | undefined;
-export declare const getProductRigidSet: (drawingId: DrawingID, productId: ObjectID, rigidSets: ObjectID[]) => number | undefined;
+export declare const getProductRigidSet: (drawingId: DrawingID, instanceId: ObjectID, rigidSets: ObjectID[]) => number | undefined;

package/build/utils/selection/scopes/mateSelection.d.ts

@@ -1,28 +1,28 @@
-import { DrawingID, ObjectID, IStructureObject } from '@buerli.io/core';
+import { DrawingID, ObjectID, ScgObject } from '@buerli.io/core';
 import { FlipType, ReorientedType } from '@buerli.io/classcad';
 /**
  * Implies the following data structure:
  * data: {
- *   matePath: ObjectID[],
- *   csys: IStructureObject,
+ *   path: ObjectID[],
+ *   csys: ScgObject,
  *   flip: FlipType,
- *   reoriented: ReorientedType,
+ *   reorient: ReorientedType,
  * }
  */
 export declare const MateScope = "HLConstraintScope";
-export declare const createMateItem: (matePath: ObjectID[], csys: IStructureObject, flip: FlipType, reoriented: ReorientedType) => {
+export declare const createMateItem: (path: ObjectID[], csys: ScgObject, flip: FlipType, reorient: ReorientedType) => {
     id: string;
     scope: string;
     data: {
-        matePath: number[];
-        csys: IStructureObject;
+        path: number[];
+        csys: ScgObject;
         flip: FlipType;
-        reoriented: ReorientedType;
+        reorient: ReorientedType;
     };
     label: string;
 };
-export declare function useIsSelected(drawingId: DrawingID, matePath: ObjectID[], csys: IStructureObject): boolean;
-export declare function useMateSelection(drawingId: DrawingID, matePath: ObjectID[], csysId: ObjectID): {
+export declare function useIsSelected(drawingId: DrawingID, path: ObjectID[], csys: ScgObject): boolean;
+export declare function useMateSelection(drawingId: DrawingID, path: ObjectID[], csysId: ObjectID): {
     isHovered: boolean;
     isSelected: boolean;
     handlers: {};

package/build/utils/selection/scopes/treeObjInteraction.d.ts

@@ -1,13 +1,13 @@
-import { DrawingID, IStructureObject, ObjectID, SelectedItem } from '@buerli.io/core';
+import { DrawingID, ScgObject, ObjectID, SelectedItem } from '@buerli.io/core';
 import { ThreeEvent } from '@react-three/fiber';
 /**
  * Implies the following data structure:
  * data: {
- *   object: IStructureObject
+ *   object: ScgObject
  * }
  */
 export declare const TreeObjScope = "TreeObjScope";
-export declare const createTreeObjSelItem: (productId: ObjectID, object: IStructureObject) => SelectedItem;
+export declare const createTreeObjSelItem: (productId: ObjectID, object: ScgObject) => SelectedItem;
 export declare function useIsGHovered(drawingId: DrawingID, objId: ObjectID): boolean;
 export declare function useIsGSelected(drawingId: DrawingID, objId: ObjectID): boolean;
 export declare function useIsSHovered(drawingId: DrawingID, objId: ObjectID): boolean;

package/build/utils/sketchIntersectionUtils.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+export declare type CCLineInfo = {
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    dir: THREE.Vector3;
+};
+export declare type CCArcInfo = {
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+    center: THREE.Vector3;
+    radius: number;
+    clockwise: boolean;
+    startAngle: number;
+    endAngle: number;
+    angularLength: number;
+};
+export declare type CCCircleInfo = {
+    center: THREE.Vector3;
+    radius: number;
+};
+export declare type SketchObjInfo = CCLineInfo | CCArcInfo | CCCircleInfo;
+export declare function getNormalizedPosition(point: THREE.Vector3, sketchObject: SketchObjInfo): number;
+export declare function getParameterizedPosition(t: number, sketchObject: SketchObjInfo): THREE.Vector3;
+export declare function intersectLineLine(line1: CCLineInfo, line2: CCLineInfo): number[][];
+export declare function intersectLineCircle(line: CCLineInfo, circle: CCCircleInfo | CCArcInfo): number[][];
+export declare function intersectLineArc(line: CCLineInfo, arc: CCArcInfo): number[][];
+export declare function intersectCircleCircle(circle1: CCCircleInfo | CCArcInfo, circle2: CCCircleInfo | CCArcInfo): number[][];
+export declare function intersectArcArc(arc1: CCArcInfo, arc2: CCArcInfo): number[][];
+export declare function intersectArcCircle(arc: CCArcInfo, circle: CCCircleInfo): number[][];