@toolpath/viewer 2.2.1 → 2.3.0

package/dist/{normalize--FiXUhO4.d.ts → normalize-C4Wj4IGK.d.ts}

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { Group, Mesh, LineSegments, Box3, Plane, BufferGeometry, Vector3, Raycaster, Object3D, Intersection, Camera } from 'three';
+import { Vector3, OrthographicCamera, PerspectiveCamera, Box3, Object3D, BufferGeometry, Group, Mesh, LineSegments, Plane, Raycaster, Intersection, Camera } from 'three';
 
 /**
  * The normalized part — the only thing the renderer consumes.
@@ -151,6 +151,207 @@ interface FocusOptions {
     readonly opacity?: number;
 }
 
+type Projection = 'orthographic' | 'perspective';
+type ViewerCamera = OrthographicCamera | PerspectiveCamera;
+interface ViewportSize {
+    readonly width: number;
+    readonly height: number;
+}
+/** Vertical field of view, in degrees, for the perspective camera. */
+declare const PERSPECTIVE_FOV = 30;
+/** Padding around the framed bounds, as a multiple of its radius. */
+declare const DEFAULT_FIT_MARGIN = 1.2;
+/** Marks scene furniture — grid, axes — that the camera should not frame. */
+declare const EXCLUDE_FROM_FRAME = "viewerExcludeFromFrame";
+/**
+ * What the camera frames: a bounding *sphere*, not a box.
+ *
+ * A sphere makes framing rotation-invariant — the part stays fully visible from
+ * every angle, and a resize never needs to know the current pose. Framing
+ * per-axis box dimensions instead means recomputing the camera distance on
+ * every resize, and still clipping on some orientations.
+ */
+interface SceneBounds {
+    readonly center: Vector3;
+    readonly radius: number;
+}
+/**
+ * Bounds for a scene with nothing in it. A viewer is mounted before it has a
+ * part, and a camera with a zero-size frustum renders nothing at all.
+ */
+declare function defaultBounds(): SceneBounds;
+/**
+ * A container can be laid out at zero size, and a degenerate aspect ratio
+ * produces a `NaN` projection matrix that never recovers. Fall back to square.
+ */
+declare function aspectRatio(size: ViewportSize): number;
+/**
+ * A world length that covers `pixels` on screen at `point`.
+ *
+ * Anything sized in world units is a thumbnail on a plate and a wall on an
+ * insert; the whole reason a control is measured this way is that it is a
+ * control rather than part of the model. The section handle and the orbit
+ * target marker both size themselves with it, which is why it lives here with
+ * the camera rather than beside either of them.
+ *
+ * The two projections answer differently on purpose. An orthographic frustum
+ * covers the same world height wherever the point is, so distance does not
+ * enter; a perspective one covers more the further away it looks, so it does.
+ */
+declare function screenLength(camera: ViewerCamera, point: Vector3, viewport: ViewportSize, pixels: number): number;
+declare function boundsFromBox(box: Box3): SceneBounds;
+/**
+ * The bounds of everything worth framing under `root`.
+ *
+ * Skips objects flagged with {@link EXCLUDE_FROM_FRAME} and their descendants:
+ * a 100 mm grid around a 6 mm part would otherwise frame the grid, and the part
+ * would be a speck.
+ */
+declare function contentBounds(root: Object3D, into: Box3): SceneBounds;
+/**
+ * Whether `object`, or anything between it and `root`, carries
+ * {@link EXCLUDE_FROM_FRAME}. The flag is set on an overlay's outermost group
+ * and means the whole subtree, so the walk goes up rather than reading the
+ * object alone.
+ */
+declare function excludedFromFrame(object: Object3D, root: Object3D): boolean;
+/**
+ * The distance at which a sphere of `radius` fits inside a perspective frustum.
+ * Uses the narrower of the two field-of-view angles, so a portrait viewport
+ * frames on width and a landscape one on height.
+ */
+declare function perspectiveFitDistance(fovDegrees: number, aspect: number, radius: number): number;
+/**
+ * Half-height of an orthographic frustum that fits a sphere of `radius`. A
+ * portrait viewport grows the height so the width still clears the sphere.
+ */
+declare function orthographicHalfHeight(aspect: number, radius: number): number;
+declare function fitDistance(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): number;
+declare function startPosition(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number): Vector3;
+/**
+ * How far out the wheel may pull, as a fraction of the fitted framing: the part
+ * may shrink to a quarter of the view and no further. Past that it is a speck
+ * with no cue that Fit is the way back.
+ */
+declare const MIN_FRAME_RATIO = 0.25;
+/**
+ * How far in the wheel may push, as a multiple of the fitted framing.
+ *
+ * Both ratios are the legacy viewer's `minZoom` 0.25 / `maxZoom` 10
+ * (`three-object.tsx:289-311`), which transfer almost exactly: legacy's
+ * orthographic frustum was `largestDimension * 2` tall and this one is the
+ * fitted bounding sphere, which for a cube agree within a few percent. So the
+ * numbers are the ones that shipped, and here they carry a meaning they did not
+ * have there — `zoom` 1 *is* the fitted framing, so 0.25 and 10 say exactly
+ * what a reader thinks they say.
+ */
+declare const MAX_FRAME_RATIO = 10;
+/** How far the camera may travel, in the two units the two cameras travel in. */
+interface CameraLimits {
+    readonly minZoom: number;
+    readonly maxZoom: number;
+    readonly minDistance: number;
+    readonly maxDistance: number;
+}
+/**
+ * The clamps for a scene, so the wheel cannot leave the viewport empty.
+ *
+ * Without them it can, from either end, and both cameras can do it: an
+ * orthographic `camera.zoom` reaches 1e30 in sixty notches, and a perspective
+ * camera dives inside the part in eight, because `minDistance` defaults to
+ * `Number.EPSILON`. Fit recovers from both — but Fit is a double middle click
+ * and nothing on screen says so, which makes it a way out rather than an
+ * answer.
+ *
+ * One rule for both cameras: the wheel may take the part from a quarter of its
+ * fitted size to ten times it. Under an orthographic camera that scale *is* the
+ * frustum, so the ratios land on `zoom`; under a perspective camera apparent
+ * size is the inverse of distance, so they land on `distance` — which is why
+ * they swap sides between the two.
+ *
+ * Pure, and derived from `bounds`, so it re-derives wherever the scene is
+ * re-measured rather than being sampled once at mount.
+ *
+ * `framed` is what the view has been framed *on*, when that is not the whole
+ * scene — `frameBox` on a single feature. The band is then taken about that
+ * framing as well as about the scene's, because a band centred on the part is
+ * the wrong band for a view of a 3 mm hole in it: ten times the *part's* fitted
+ * size can be less than once the hole's, so the framing the caller asked for sat
+ * outside the clamps meant to keep it in view. Under an orthographic camera
+ * `zoom` is measured against a frustum still sized to the scene, so the framing
+ * enters as the zoom ratio it takes to reach; under a perspective one it enters
+ * as its own fitted distance.
+ *
+ * Widened to the union of the two rather than moved onto `framed`, and that is
+ * the whole of why this takes both. A band that simply followed the last framing
+ * would take the part away: framing a hole would put "far enough out to see what
+ * the hole is in" past `maxDistance`, so the wheel could no longer get back to
+ * the part it had just been looking at, and Fit — a gesture with nothing on
+ * screen to say so — would be the only way. Reaching further in must not cost
+ * the reach back out, so each end takes whichever bound is looser. With no
+ * `framed`, or one the size of the scene, both ends collapse to the scene's own
+ * and this is the function it was before.
+ */
+declare function cameraLimits(projection: Projection, size: ViewportSize, bounds: SceneBounds, margin?: number, framed?: SceneBounds): CameraLimits;
+/**
+ * The box the orbit target is confined to — the fitted framing, several frames
+ * over. Written into `into` so the per-frame path allocates nothing.
+ */
+declare function targetBoundary(bounds: SceneBounds, into: Box3, margin?: number): Box3;
+/**
+ * Points an existing camera's frustum at `bounds` for the current viewport.
+ * Pose is untouched — that belongs to the controls.
+ */
+declare function applyProjection(camera: ViewerCamera, size: ViewportSize, bounds: SceneBounds, margin?: number): void;
+/**
+ * The world-up convention. The part data is Z-up (millimetres, no conversion) —
+ * not the glTF-conventional Y-up — so the camera has to say so explicitly.
+ */
+declare const CAD_CAMERA_UP: Vector3;
+/**
+ * `up` re-squared against a view direction: the part of it perpendicular to
+ * `view`, written into `into`.
+ *
+ * This is what keeps the horizon level while a free orbit carries the camera
+ * over a pole — the up vector follows the view instead of flipping. The
+ * controls run it on every update, which is what makes the next sentence the
+ * important one.
+ *
+ * **It is path-dependent.** It is a projection, so it discards the component it
+ * removes and cannot put it back: running it at one view and then another does
+ * not give what running it once at the second view would. So a camera carries
+ * the roll of every pose it has passed through, and any pose that is meant to
+ * be canonical — the opening frame, a reset, a named view — has to say what
+ * `up` is rather than inherit it. `viewer.tsx` does, at `resetContent`. The
+ * test beside this pins both halves.
+ *
+ * `into` may be `view` or `up` — three.js `crossVectors` reads all six
+ * components before it writes any, and the intermediate is this module's own
+ * scratch, so writing the result over an input is safe. Said here because this
+ * is exported and an out-parameter invites the question; the test beside this
+ * pins it, so a three.js change cannot quietly turn the answer around.
+ *
+ * `view` and `up` being parallel is the one degenerate case: their cross is
+ * zero, `normalize` leaves it zero, and the result is a zero vector rather than
+ * an error. A caller with a free-orbiting camera reaches that at the pole,
+ * which is what `freeOrbit` and a squared `up` at every canonical pose exist to
+ * keep it away from.
+ */
+declare function adaptedUp(view: Vector3, up: Vector3, into: Vector3): Vector3;
+/** Named viewing directions, as unit vectors from the part toward the camera. */
+declare const cadViewDirections: {
+    readonly front: Vector3;
+    readonly back: Vector3;
+    readonly left: Vector3;
+    readonly right: Vector3;
+    readonly top: Vector3;
+    readonly bottom: Vector3;
+    readonly isometric: Vector3;
+};
+type ViewerView = keyof typeof cadViewDirections;
+/** The current orbit direction, so Fit can retain the direction being looked from. */
+declare function currentViewDirection(camera: ViewerCamera, target: Vector3, into: Vector3): Vector3;
+
 /**
  * Viewer colors.
  *
@@ -182,6 +383,8 @@ interface ViewerTheme {
     /** `EdgesGeometry` line color and opacity. */
     readonly edge: number;
     readonly edgeOpacity: number;
+    /** The sharp corners `<PartMesh sharpCorners>` draws. */
+    readonly sharpCorner: number;
     /**
      * The capped face of a section cut: its fill, and the hatch lines drawn over
      * it. The cap's edge takes {@link ViewerTheme.sectionHandleOutline}.
@@ -249,6 +452,100 @@ declare function themesEqual(a: ViewerTheme, b: ViewerTheme): boolean;
 /** The color for a candidate direction, wrapping at {@link DIRECTION_COLORS}. */
 declare function directionColor(index: number): number;
 
+/**
+ * Every place two surfaces of the part meet, with how sharply and which way
+ * they fold there, and the two regions either side.
+ *
+ * This finds edges; it does not judge them. Which corners are a problem is the
+ * DFM rules' call, from the Engine's measurements (see
+ * {@link SharpCornerOptions.features}) — geometry alone calls every hole's rim
+ * and every stud's base sharp, and neither is anything an end mill minds. What
+ * the mesh contributes is *where*: the exact edges to draw for a feature the
+ * rules have already flagged.
+ *
+ * The walk is the one `regionEdgesGeometry` makes — an edge between two visual
+ * surfaces is a real edge of the part, an edge inside one is tessellation — and
+ * then each such edge is measured from the two triangles either side of it:
+ *
+ * - **The angle** between their normals. A fillet or a blend meets its
+ *   neighbours tangentially, so it reads near 0°; a square shoulder reads 90°.
+ *   On real Engine parts the two populations do not overlap — creases sit at
+ *   60–100°, tangent seams under 10°.
+ * - **Which way it folds.** Concave where each triangle's far corner stands in
+ *   front of the other's plane: an inside corner.
+ *
+ * Endpoints are matched by **quantised position** — `keyFor`, the key
+ * `regionAdjacency` uses, so the two agree on a shared vertex — not by exact
+ * float: the two triangles either side of an edge belong to two
+ * surfaces tessellated separately, and the pairing is the whole measurement.
+ * The Engine's meshes are watertight — every edge on the parts measured is met
+ * by exactly two triangles — so an edge met once is a hole in a mesh from
+ * somewhere else and is skipped, and one met a third time keeps the first pair.
+ *
+ * The mesh must be non-indexed, which `parsePartGeometry` guarantees.
+ */
+interface SurfaceCreases {
+    /** How many segments. */
+    readonly count: number;
+    /** Each segment's two endpoints, `x y z x y z`, in the geometry's own space. */
+    readonly positions: Float32Array;
+    /** Degrees between the two faces' normals: 0 is smooth, 90 is square. */
+    readonly angles: Float32Array;
+    /** 1 where the surfaces fold inward — an inside corner — and 0 where they fold outward. */
+    readonly concave: Uint8Array;
+    /** The region `idx` either side of each segment, two to a segment; `-1` for a triangle in none. */
+    readonly regions: Int32Array;
+    /**
+     * The far corner of the triangle either side of each segment, `x y z x y z`:
+     * which way each face runs on from the corner, and how far.
+     */
+    readonly fars: Float32Array;
+}
+interface SharpCornerOptions {
+    /**
+     * The features the DFM rules flag with a sharp corner — those whose
+     * `featureSheet(datasheet).sharpCorners` is set, from `@toolpath/dfm/model`.
+     * Each one's inside corners that run along its machining direction are
+     * drawn: the vertical corners between its walls that no end mill makes.
+     * Nothing else is. Tags are matched without regard to case.
+     */
+    readonly features: readonly FeatureTag[];
+}
+/** Finds and measures every crease between two visual surfaces. See {@link SurfaceCreases}. */
+declare function surfaceCreases(geometry: BufferGeometry, model: Pick<PartModel, 'regions'>): SurfaceCreases;
+/**
+ * One sharp corner the DFM rules flag, as drawn: a run of crease segments end
+ * to end along its feature's machining direction — usually one, more where the
+ * mesh splits the corner.
+ */
+interface SharpCorner {
+    /** Its place among the part's corners, stable while the flagged features are. */
+    readonly index: number;
+    /** The flagged feature it belongs to, as the part model spells the tag. */
+    readonly feature: FeatureTag;
+    /** Its two ends, in the part's own space. */
+    readonly start: Vec3;
+    readonly end: Vec3;
+    /** How far it runs, mm: as deep as a tool would have to reach to make it. */
+    readonly length: number;
+    /** The angle between the two faces that meet in it, degrees: 90 for a square corner. */
+    readonly angle: number;
+    /** The regions either side of it. */
+    readonly regions: readonly number[];
+    /** Its segments, as indices into the {@link SurfaceCreases} it was found in. */
+    readonly segments: readonly number[];
+}
+/**
+ * The flagged features' corners: each inside crease with a flagged feature's
+ * face on either side of it, running along that feature's machining direction,
+ * joined end to end into whole corners. A floor meeting a wall square is a
+ * flat end mill's ordinary work, and runs across the direction rather than
+ * along it.
+ */
+declare function findSharpCorners(creases: SurfaceCreases, model: Pick<PartModel, 'features' | 'regionIndex'>, options: SharpCornerOptions): SharpCorner[];
+/** The flagged features' corners, as `x y z x y z` endpoint pairs. See {@link findSharpCorners}. */
+declare function sharpCornerPositions(creases: SurfaceCreases, model: Pick<PartModel, 'features' | 'regionIndex'>, options: SharpCornerOptions): Float32Array;
+
 /** The vertex attribute carrying each vertex's column in the state texture. */
 declare const REGION_ATTRIBUTE = "aRegion";
 type PartDisplay = 'solid' | 'wireframe';
@@ -295,6 +592,24 @@ interface PartObject {
     setTheme(theme: ViewerTheme): void;
     /** Semantic edges only in wireframe; painted faces remain visible for interaction. */
     setDisplay(display: PartDisplay, showEdges?: boolean): void;
+    /**
+     * Draws the sharp corners of the features the DFM rules flag, bold and
+     * through the part — see `render/sharp-corners.ts`. `null` hides them. Setting what is already drawn
+     * costs a string comparison, so a caller may pass a fresh object each render.
+     */
+    setSharpCorners(options: SharpCornerOptions | null): void;
+    /** The corners drawn now, in the order their `index` counts; none while they are off. */
+    sharpCorners(): readonly SharpCorner[];
+    /**
+     * The drawn corner under a pointer on the part — `point` in world space,
+     * `region` the face it hit — or `null`. See `sharpCornerAt`.
+     */
+    sharpCornerAt(hit: {
+        readonly point: Vector3;
+        readonly region: number;
+    }, camera: ViewerCamera, viewport: ViewportSize): SharpCorner | null;
+    /** Draws one corner up as the one under the pointer; `null` for none. */
+    setHoveredSharpCorner(index: number | null): void;
     dispose(): void;
 }
 interface RegionPaint {
@@ -719,6 +1034,13 @@ interface PartPick {
      * part, and is nobody else's to answer.
      */
     readonly doubled: boolean;
+    /**
+     * The sharp corner under the pointer, when `<PartMesh sharpCorners>` is
+     * drawing them and the pointer is on one: within a few pixels of it, on one
+     * of the two faces that meet there. The face is still `region`; this says the
+     * pointer is on the corner drawn over it.
+     */
+    readonly sharpCorner?: SharpCorner;
 }
 /** A unit vector from the part toward the camera, for the owner ranking. */
 declare function viewDirection(camera: Camera, target: Vector3): Vec3;
@@ -850,6 +1172,14 @@ interface PartMeshProps {
     onPick?: (pick: PartPick) => void;
     theme?: Partial<ViewerTheme>;
     showEdges?: boolean;
+    /**
+     * Draws the sharp corners of the features the DFM rules flag — `features`,
+     * those whose `featureSheet(datasheet).sharpCorners` is set — bold, and
+     * faintly through the part where it hides them. The rules decide which
+     * corners; the mesh only says where they are. Off when omitted or `null`.
+     * Coloured by the theme's `sharpCorner`.
+     */
+    sharpCorners?: SharpCornerOptions | null;
     /** Wireframe shows region boundaries and any hovered/painted faces, with no triangle diagonals. */
     display?: PartDisplay;
     /**
@@ -868,7 +1198,7 @@ interface PartMeshProps {
  * React render at all: the hovered face lives in a ref, and routing it through
  * state is what this rewrite exists to stop doing.
  */
-declare const PartMesh: ({ model, geometry, selection, focus, candidates, highlights, regionHighlights, pickedRegions, hoveredFeatureIds, hover, activeDirection, section, onSectionChange, onAdjacency, focusFeature, onHover, onPick, theme, showEdges, display, children, }: PartMeshProps) => react.JSX.Element;
+declare const PartMesh: ({ model, geometry, selection, focus, candidates, highlights, regionHighlights, pickedRegions, hoveredFeatureIds, hover, activeDirection, section, onSectionChange, onAdjacency, focusFeature, onHover, onPick, theme, showEdges, sharpCorners, display, children, }: PartMeshProps) => react.JSX.Element;
 
 interface EnginePartProps extends Omit<PartMeshProps, 'model' | 'geometry'> {
     /**
@@ -943,4 +1273,4 @@ declare function normalizePartReport(report: unknown): PartModel;
  */
 declare function assertSupportedKernelVersion(kernelVersion: string): void;
 
-export { type SectionAnchor as $, AXES_PLANE_OFFSET as A, type BuildPickInput as B, CANDIDATE_WEIGHT as C, DEFAULT_SECTION_NORMAL as D, EnginePart as E, type FeatureTag as F, PREVIEW_SCALE as G, HANDLE_PIXELS as H, type PartDisplay as I, PartMesh as J, type KnownFeatureType as K, type PartMeshProps as L, MIN_KERNEL_VERSION as M, NO_MODIFIERS as N, OUTLINE_SCALE as O, type PartModel as P, type PartObject as Q, type RegionHighlight as R, type SectionOptions as S, type TriangleRange as T, type PickModifiers as U, type Vec3 as V, type PointerLocation as W, REGION_ATTRIBUTE as X, type RegionPaint as Y, SECTION_GIZMO_FRAME_SCALE as Z, SECTION_RENDER_ORDER as _, type PartMeshRefs as a, type SectionBounds as a0, type SectionPlacement as a1, type ShapeKind as a2, type SurfaceHit as a3, applyHighlightLayers as a4, axesPlanes as a5, buildPick as a6, buildRegionAttribute as a7, buildRegionTexels as a8, createPart as a9, directionColor as aa, dragPlane as ab, focusForPick as ac, hitUnderRay as ad, pickedStartDepth as ae, resolveTheme as af, sectionAnchor as ag, sectionBounds as ah, sectionConstant as ai, sectionDepth as aj, sectionDepthConstant as ak, sectionDepthRange as al, sectionFromPick as am, sectionMeasurement as an, sectionOffset as ao, sectionOptionsFromState as ap, sectionPlane as aq, surfaceUnderRay as ar, themesEqual as as, viewDirection as at, type EnginePartProps as b, assertSupportedKernelVersion as c, type PartPick as d, type ViewerTheme as e, type SectionState as f, type PartModelRegion as g, type RegionIndex as h, type PartModelFeature as i, type FeatureType as j, AXES_PLANE_SCALE as k, type AxesPlane as l, CAP_HATCH as m, normalizePartReport as n, DEFAULT_THEME as o, DIRECTION_COLORS as p, DISABLED_SECTION as q, type FeatureHighlight as r, smoothRegionNormals as s, type FocusOptions as t, HIGHLIGHT_COLORS as u, HIGHLIGHT_WEIGHT as v, HOVER_WEIGHT as w, type HighlightLayers as x, type KnownShapeKind as y, PICKED_SURFACE_LABEL as z };
+export { PREVIEW_SCALE as $, AXES_PLANE_OFFSET as A, type BuildPickInput as B, type CameraLimits as C, DEFAULT_FIT_MARGIN as D, EnginePart as E, type FeatureTag as F, type FeatureHighlight as G, type FocusOptions as H, HANDLE_PIXELS as I, HIGHLIGHT_COLORS as J, HIGHLIGHT_WEIGHT as K, HOVER_WEIGHT as L, MIN_KERNEL_VERSION as M, type HighlightLayers as N, type KnownFeatureType as O, type PartModel as P, type KnownShapeKind as Q, type RegionHighlight as R, type SectionOptions as S, type TriangleRange as T, MAX_FRAME_RATIO as U, type Vec3 as V, MIN_FRAME_RATIO as W, NO_MODIFIERS as X, OUTLINE_SCALE as Y, PERSPECTIVE_FOV as Z, PICKED_SURFACE_LABEL as _, type PartMeshRefs as a, viewDirection as a$, type PartDisplay as a0, PartMesh as a1, type PartMeshProps as a2, type PartObject as a3, type PickModifiers as a4, type PointerLocation as a5, REGION_ATTRIBUTE as a6, type RegionPaint as a7, SECTION_GIZMO_FRAME_SCALE as a8, SECTION_RENDER_ORDER as a9, excludedFromFrame as aA, findSharpCorners as aB, fitDistance as aC, focusForPick as aD, hitUnderRay as aE, orthographicHalfHeight as aF, perspectiveFitDistance as aG, pickedStartDepth as aH, resolveTheme as aI, screenLength as aJ, sectionAnchor as aK, sectionBounds as aL, sectionConstant as aM, sectionDepth as aN, sectionDepthConstant as aO, sectionDepthRange as aP, sectionFromPick as aQ, sectionMeasurement as aR, sectionOffset as aS, sectionOptionsFromState as aT, sectionPlane as aU, sharpCornerPositions as aV, startPosition as aW, surfaceCreases as aX, surfaceUnderRay as aY, targetBoundary as aZ, themesEqual as a_, type SceneBounds as aa, type SectionAnchor as ab, type SectionBounds as ac, type SectionPlacement as ad, type ShapeKind as ae, type SharpCorner as af, type SharpCornerOptions as ag, type SurfaceCreases as ah, type SurfaceHit as ai, adaptedUp as aj, applyHighlightLayers as ak, applyProjection as al, aspectRatio as am, axesPlanes as an, boundsFromBox as ao, buildPick as ap, buildRegionAttribute as aq, buildRegionTexels as ar, cadViewDirections as as, cameraLimits as at, contentBounds as au, createPart as av, currentViewDirection as aw, defaultBounds as ax, directionColor as ay, dragPlane as az, type EnginePartProps as b, assertSupportedKernelVersion as c, type PartPick as d, type ViewerTheme as e, type SectionState as f, type ViewerCamera as g, type ViewportSize as h, type PartModelRegion as i, type ViewerView as j, type Projection as k, type RegionIndex as l, type PartModelFeature as m, normalizePartReport as n, type FeatureType as o, AXES_PLANE_SCALE as p, type AxesPlane as q, CAD_CAMERA_UP as r, smoothRegionNormals as s, CANDIDATE_WEIGHT as t, CAP_HATCH as u, DEFAULT_SECTION_NORMAL as v, DEFAULT_THEME as w, DIRECTION_COLORS as x, DISABLED_SECTION as y, EXCLUDE_FROM_FRAME as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolpath/viewer",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "React Three Fiber viewer for Toolpath Engine part reports",
   "license": "MIT",
   "engines": {