@giszhc/three-model-viewer 0.0.0-stage → 1.0.0

package/dist/loaders/ModelLoader.d.ts

@@ -0,0 +1,69 @@
+import { ModelLoadResult, ModelDisplayStyle } from '../types';
+import * as THREE from 'three';
+export interface ManagedMeshMaterial {
+    mesh: THREE.Mesh;
+    originalMaterial: THREE.Material | THREE.Material[];
+    plainMaterial: THREE.Material;
+}
+export declare class ModelLoader {
+    private currentZipContent;
+    private managedMaterials;
+    private isTextureEnabled;
+    private displayStyle;
+    private plainColor;
+    private currentClippingPlanes;
+    /**
+     * Load model from a ZIP file containing .obj, .mtl, and image textures
+     */
+    loadZip(source: File | Blob | ArrayBuffer | string, onProgress?: (percent: number, message: string) => void): Promise<ModelLoadResult>;
+    /**
+     * Load model directly from OBJ and optional MTL URLs
+     */
+    loadOBJ(objUrl: string, mtlUrl?: string, onProgress?: (percent: number, message: string) => void): Promise<ModelLoadResult>;
+    /**
+     * Post-process loaded model:
+     * - Build BVH acceleration trees on all meshes
+     * - Count vertices & faces
+     * - Cache original materials and prepare clay/white-model materials
+     * - Calculate bounding box and center
+     */
+    postProcessModel(group: THREE.Group): ModelLoadResult;
+    /**
+     * Internal helper to apply display style (solid/wireframe) to a managed mesh
+     */
+    private applyStyleToItem;
+    /**
+     * Set model display style: 'solid' (实体), 'wireframe' (线框)
+     */
+    setDisplayStyle(style: ModelDisplayStyle): void;
+    getDisplayStyle(): ModelDisplayStyle;
+    /**
+     * Toggle texture on/off
+     */
+    toggleTexture(showTexture: boolean): void;
+    getTextureState(): boolean;
+    /**
+     * Set color for non-texture display (defaults to Digital3DCloud standard CAD blue 0x4c8cd6)
+     */
+    setPlainColor(color: THREE.ColorRepresentation): void;
+    getPlainColor(): number;
+    /**
+     * Retrieves the maximum original texture resolution (width & height) from the model's materials
+     */
+    getModelTextureSize(): {
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * Retrieve all meshes of the model for raycasting and snapping
+     */
+    getMeshes(): THREE.Mesh[];
+    /**
+     * Apply clipping planes to all materials
+     */
+    applyClippingPlanes(planes: THREE.Plane[]): void;
+    /**
+     * Clean up resources
+     */
+    cleanup(): void;
+}

package/dist/loaders/ZipExtractor.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+export interface ExtractedZipContent {
+    objContent: string | ArrayBuffer;
+    objFileName: string;
+    mtlContent: string | null;
+    mtlFileName: string | null;
+    blobUrls: Map<string, string>;
+    loadingManager: THREE.LoadingManager;
+    dispose: () => void;
+}
+export type ProgressCallback = (percent: number, message: string) => void;
+export declare class ZipExtractor {
+    static extract(source: File | Blob | ArrayBuffer | string, onProgress?: ProgressCallback): Promise<ExtractedZipContent>;
+}

package/dist/style.css

@@ -0,0 +1,2 @@
+.gmv-css2d-label{pointer-events:none;-webkit-user-select:none;user-select:none;z-index:10;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}.gmv-measure-badge{-webkit-backdrop-filter:blur(8px);color:#fff;white-space:nowrap;background:#121621e0;border:1px solid #ffffff2e;border-radius:6px;align-items:center;gap:6px;padding:4px 10px;font-size:12px;font-weight:500;transition:all .2s;display:inline-flex;transform:translate(-50%,-50%);box-shadow:0 4px 14px #00000059}.gmv-measure-badge.distance{border-left:3px solid #3b82f6}.gmv-measure-badge.height{border-left:3px solid #10b981}.gmv-measure-badge.area{border-left:3px solid #f59e0b}.gmv-measure-badge.volume{border-left:3px solid #8b5cf6}.gmv-measure-badge.angle{border-left:3px solid #ec4899}.gmv-volume-badge{-webkit-backdrop-filter:blur(10px);color:#fff;white-space:nowrap;pointer-events:none;background:#121621eb;border:1px solid #8b5cf666;border-left:3px solid #8b5cf6;border-radius:8px;flex-direction:column;align-items:center;gap:3px;padding:6px 12px;font-size:12px;font-weight:500;display:inline-flex;transform:translate(-50%,-100%);box-shadow:0 6px 20px #00000073}.gmv-dimension-badge{-webkit-backdrop-filter:blur(6px);backdrop-filter:blur(6px);color:#e2e8f0;letter-spacing:.3px;pointer-events:none;background:#141824d9;border:1px solid #ffffff26;border-radius:4px;align-items:center;gap:4px;padding:2px 8px;font-size:11px;font-weight:600;display:inline-flex;transform:translate(-50%,-50%);box-shadow:0 2px 8px #0000004d}.gmv-dimension-badge.dim-x{color:#f87171;border-color:#ef444466}.gmv-dimension-badge.dim-y{color:#34d399;border-color:#10b98166}.gmv-dimension-badge.dim-z{color:#60a5fa;border-color:#3b82f666}[data-theme=light] .gmv-dimension-badge{color:#1e293b;background:#ffffffeb;border-color:#00000026;box-shadow:0 4px 12px #0000001a}[data-theme=light] .gmv-measure-badge{color:#0f172a;background:#fffffff0;border-color:#00000026;box-shadow:0 6px 18px #0000001f}.gmv-interaction-tip{color:#f8fafc;pointer-events:none;z-index:100;background:#0f172ae6;border:1px solid #ffffff26;border-radius:9999px;align-items:center;gap:8px;padding:8px 16px;font-size:13px;transition:opacity .2s,transform .2s;display:flex;position:absolute;bottom:24px;left:50%;transform:translate(-50%);box-shadow:0 4px 16px #0000004d}.gmv-interaction-tip.hidden{opacity:0;pointer-events:none;transform:translate(-50%,10px)}.gmv-loading-overlay{-webkit-backdrop-filter:blur(12px);z-index:999;opacity:0;pointer-events:none;background:#0a0f1dbf;justify-content:center;align-items:center;transition:opacity .3s cubic-bezier(.16,1,.3,1);display:flex;position:absolute;inset:0}.gmv-loading-overlay.active{opacity:1;pointer-events:auto}.gmv-loading-card{text-align:center;background:#161e31f0;border:1px solid #38bdf859;border-radius:16px;flex-direction:column;align-items:center;gap:14px;width:380px;padding:24px 28px;transition:transform .3s cubic-bezier(.16,1,.3,1);display:flex;transform:scale(.92);box-shadow:0 20px 50px #0009,0 0 30px #38bdf833}.gmv-loading-overlay.active .gmv-loading-card{transform:scale(1)}.gmv-spinner-ring{border:3px solid #38bdf82e;border-top-color:#38bdf8;border-radius:50%;width:44px;height:44px;animation:.85s linear infinite gmv-spin}@keyframes gmv-spin{to{transform:rotate(360deg)}}.gmv-loading-title{color:#f1f5f9;letter-spacing:.3px;font-size:15px;font-weight:600}.gmv-loading-status{color:#94a3b8;white-space:nowrap;text-overflow:ellipsis;max-width:320px;min-height:18px;font-size:12px;overflow:hidden}.gmv-progress-track{background:#33415599;border-radius:999px;width:100%;height:6px;position:relative;overflow:hidden}.gmv-progress-bar{background:linear-gradient(90deg,#0284c7,#38bdf8,#818cf8);border-radius:999px;width:0%;height:100%;transition:width .25s cubic-bezier(.16,1,.3,1);box-shadow:0 0 12px #38bdf880}.gmv-progress-text{color:#38bdf8;align-self:flex-end;margin-top:-6px;font-size:12px;font-weight:700}.gmv-plane-badge{pointer-events:none;-webkit-user-select:none;user-select:none;-webkit-backdrop-filter:blur(8px);color:#fff;white-space:nowrap;border:1px solid #ffffff40;border-radius:6px;align-items:center;gap:4px;padding:3px 8px;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif;font-size:11px;font-weight:600;display:inline-flex;box-shadow:0 4px 14px #00000073}.gmv-plane-badge-x{background:#dc2626e0;border-color:#f87171}.gmv-plane-badge-y{background:#059669e0;border-color:#34d399}.gmv-plane-badge-z{background:#2563ebe0;border-color:#60a5fa}
+/*$vite$:1*/

package/dist/tools/BoundingBoxTool.d.ts

@@ -0,0 +1,36 @@
+import { BoundingBoxOptions } from '../types';
+import * as THREE from 'three';
+export declare class BoundingBoxTool {
+    private scene;
+    private boxGroup;
+    private wireframeBox;
+    private lineX;
+    private lineY;
+    private lineZ;
+    private labelX;
+    private labelY;
+    private labelZ;
+    private currentModel;
+    private isVisible;
+    private unit;
+    private localVertices;
+    private worldVertices;
+    private modelSize;
+    constructor(scene: THREE.Scene);
+    /**
+     * Attaches bounding box to a model and initializes dynamic dimensional lines
+     */
+    attachToModel(model: THREE.Object3D, options?: Partial<BoundingBoxOptions>): void;
+    private createDynamicLine;
+    /**
+     * Updates bounding box and selects the CURRENT front-facing 3 edges dynamically
+     * based on the model's current rotation and camera perspective!
+     */
+    update(camera: THREE.Camera): void;
+    private updateLine;
+    setVisible(visible: boolean): void;
+    getVisible(): boolean;
+    setUnit(unit: string): void;
+    detach(): void;
+    destroy(): void;
+}

package/dist/tools/CameraTool.d.ts

@@ -0,0 +1,39 @@
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { TrackballControls } from 'three/addons/controls/TrackballControls.js';
+import { AutoRotateAxis, AutoRotateDirection, AutoRotateOptions, CameraView, RotationLockAxis } from '../types';
+import * as THREE from 'three';
+import * as TWEEN from '@tweenjs/tween.js';
+export declare class CameraTool {
+    private camera;
+    private controls;
+    private tweenGroup;
+    private currentTween;
+    private isAutoRotating;
+    private autoRotateAxis;
+    private autoRotateDirection;
+    private autoRotateSpeed;
+    private lockedAxis;
+    private lockedPitchAngle;
+    private lockedYawAngle;
+    constructor(camera: THREE.PerspectiveCamera, controls: OrbitControls | TrackballControls, tweenGroup?: TWEEN.Group);
+    setAutoRotate(enabled: boolean, axis?: AutoRotateAxis, direction?: AutoRotateDirection, speed?: number): void;
+    toggleAutoRotate(): boolean;
+    setAutoRotateAxis(axis: AutoRotateAxis): void;
+    setAutoRotateDirection(direction: AutoRotateDirection): void;
+    setAutoRotateSpeed(speed: number): void;
+    getAutoRotateState(): AutoRotateOptions;
+    setLockedAxis(axis: RotationLockAxis): void;
+    getLockedAxis(): RotationLockAxis;
+    /**
+     * Called each frame in render loop to apply auto-rotation and axis lock constraints
+     */
+    updatePerFrame(): void;
+    /**
+     * Smoothly transitions the camera to one of the 8 standard view orientations
+     */
+    setView(view: CameraView, targetObject: THREE.Object3D, duration?: number): Promise<void>;
+    /**
+     * Fits camera to view the whole object from current angle
+     */
+    fitToObject(object: THREE.Object3D, duration?: number): Promise<void>;
+}

package/dist/tools/ClippingTool.d.ts

@@ -0,0 +1,140 @@
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { TrackballControls } from 'three/addons/controls/TrackballControls.js';
+import { ModelLoader } from '../loaders/ModelLoader';
+import { ClippingAxis, SectioningState } from '../types';
+import { EventEmitter } from '../core/EventEmitter';
+import * as THREE from 'three';
+export declare class ClippingTool {
+    private scene;
+    private camera;
+    private container;
+    private modelLoader;
+    private controls;
+    private emitter;
+    private planeX;
+    private planeY;
+    private planeZ;
+    private customPlane;
+    private isEnabled;
+    private activeAxis;
+    private helperVisible;
+    private planesGroup;
+    private interactive;
+    private widgets;
+    private isDraggingPlane;
+    private draggedWidget;
+    private dragStartPointer;
+    private dragStartPosition;
+    private dragScreenAxis;
+    private dragScreenAxisLenSq;
+    private raycaster;
+    private hoveredAxis;
+    private isPickingCustomPoints;
+    private customPoints;
+    private customMarkersGroup;
+    private modelBox;
+    private onPointerDownBound;
+    private onPointerMoveBound;
+    private onPointerMoveDragBound;
+    private onPointerUpDragBound;
+    private onDoubleClickBound;
+    constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, container: HTMLElement, modelLoader: ModelLoader, controls?: OrbitControls | TrackballControls, emitter?: EventEmitter);
+    setControls(controls: OrbitControls | TrackballControls): void;
+    setEmitter(emitter: EventEmitter): void;
+    setInteractive(interactive: boolean): void;
+    /**
+     * Initializes or updates bounds from loaded model
+     */
+    setModelBounds(box: THREE.Box3): void;
+    /**
+     * Builds the 3 interactive clipping planes strictly fitting inside the model's bounding box
+     */
+    private rebuildPlaneWidgets;
+    private createPlaneWidget;
+    private clearPlaneWidgets;
+    private updateWidgetsVisibility;
+    /**
+     * 1. 开启 / 关闭 剖切总开关 (Enable/Disable Sectioning)
+     */
+    setSectioningEnabled(enabled: boolean): void;
+    getSectioningEnabled(): boolean;
+    /**
+     * 2. 独立开启或关闭某个轴的剖切 (Multi-Axis Toggle)
+     * 支持 X、Y、Z 任意多轴同时开启与同时剖切！
+     */
+    setAxisEnabled(axis: ClippingAxis, enabled: boolean): void;
+    toggleAxis(axis: ClippingAxis, enabled?: boolean): boolean;
+    isAxisEnabled(axis: ClippingAxis): boolean;
+    /**
+     * 设置激活/聚焦的轴向 (兼容已有调用)
+     */
+    setSectioningAxis(axis: ClippingAxis): void;
+    getSectioningAxis(): ClippingAxis;
+    /**
+     * 3. 隐藏 / 显示 剖切辅助面 (Hide Sectional Plane while keeping the cut)
+     */
+    setSectioningHelperVisible(visible: boolean): void;
+    getSectioningHelperVisible(): boolean;
+    /**
+     * 4. 独立反向某轴剖切 (Reverse Sectioning for a specific axis or active axis)
+     */
+    setAxisReverse(axis: ClippingAxis, reverse: boolean): void;
+    setSectioningReverse(reverse: boolean): void;
+    getSectioningReverse(): boolean;
+    invertAxis(axis: ClippingAxis): boolean;
+    /**
+     * 5. 重置剖切面至中心位置与默认正向状态
+     */
+    resetSectioning(axis?: ClippingAxis): void;
+    /**
+     * 获取多轴综合剖切状态
+     */
+    getSectioningState(): SectioningState;
+    private emitSectioningState;
+    private handlePointerDown;
+    private handlePointerMoveDrag;
+    private handlePointerUpDrag;
+    /**
+     * Hover highlighting across all enabled planes
+     */
+    private handlePointerMove;
+    private setHoveredAxis;
+    /**
+     * Double click on any plane quickly flips/inverts slicing direction of that specific plane
+     */
+    private handleDoubleClick;
+    setPlanePositionExplicit(axis: ClippingAxis, pos: number): void;
+    setAxisProgress(axis: ClippingAxis, progress: number): void;
+    getAxisProgress(axis: ClippingAxis): number;
+    private disableAxisInternal;
+    private disableAllAxesPlanes;
+    setAxisClipping(axis: ClippingAxis, progress: number, inverted?: boolean): void;
+    disableAxis(axis: ClippingAxis): void;
+    getAxisState(axis: ClippingAxis): {
+        enabled: boolean;
+        progress: number;
+        inverted: boolean;
+        position: number;
+    };
+    setPlanesVisible(visible: boolean): void;
+    getPlanesVisible(): boolean;
+    startCustomClip(): void;
+    cancelCustomClip(): void;
+    clearCustomPlane(): void;
+    invertCustomClip(): boolean;
+    hasCustomPlane(): boolean;
+    private handleCustomPointPick;
+    private addCustomPoint;
+    /**
+     * Updates custom knife markers to maintain constant pixel size on screen
+     */
+    updatePerFrame(viewportHeight?: number): void;
+    private updateSingleMarkerScale;
+    private clearCustomMarkers;
+    /**
+     * Applies all currently active clipping planes to model materials simultaneously!
+     */
+    private applyPlanes;
+    resetAll(): void;
+    destroy(): void;
+}

package/dist/tools/MeasurementTool.d.ts

@@ -0,0 +1,61 @@
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
+import { TrackballControls } from 'three/addons/controls/TrackballControls.js';
+import { ModelLoader } from '../loaders/ModelLoader';
+import { EventEmitter } from '../core/EventEmitter';
+import { MeasurementResult, MeasurementType } from '../types';
+import * as THREE from 'three';
+export declare class MeasurementTool {
+    private scene;
+    private camera;
+    private container;
+    private modelLoader;
+    private emitter;
+    private controls;
+    private currentMode;
+    private unit;
+    private measurementGroup;
+    private results;
+    private activePoints;
+    private activePreviewGroup;
+    private activeMarkersGroup;
+    private activeLineGroup;
+    private snapCursorMesh;
+    private onPointerDownBound;
+    private onPointerMoveBound;
+    private onDoubleClickBound;
+    constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, container: HTMLElement, modelLoader: ModelLoader, emitter: EventEmitter, controls?: OrbitControls | TrackballControls);
+    setControls(controls: OrbitControls | TrackballControls): void;
+    setUnit(unit: string): void;
+    setMode(mode: MeasurementType): void;
+    getMode(): MeasurementType;
+    getControls(): OrbitControls | TrackballControls | null;
+    private addListeners;
+    private removeListeners;
+    private handlePointerMove;
+    private handlePointerDown;
+    private addActiveMarker;
+    private handleDoubleClick;
+    private updateDynamicPreview;
+    private finishDistanceMeasurement;
+    private finishHeightMeasurement;
+    private finishAreaMeasurement;
+    private finishAngleMeasurement;
+    private addEndSphere;
+    undoLastPoint(): void;
+    cancelActive(): void;
+    private clearActiveLine;
+    private clearActiveMarkers;
+    /**
+     * Updates scale of all marker spheres dynamically per frame so they maintain
+     * a constant screen pixel size, completely independent of camera distance or model zoom!
+     */
+    updatePerFrame(viewportHeight?: number): void;
+    private updateSingleMeshScale;
+    /**
+     * Completely clears ALL measurements and CSS2D DOM elements
+     */
+    clearAll(): void;
+    private disposeObjectHierarchy;
+    getResults(): MeasurementResult[];
+    destroy(): void;
+}

package/dist/tools/ScreenshotTool.d.ts

@@ -0,0 +1,21 @@
+import { ExportImageOptions } from '../types';
+import * as THREE from 'three';
+export declare class ScreenshotTool {
+    private renderer;
+    private scene;
+    private camera;
+    private getModel;
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.PerspectiveCamera, getModel?: () => THREE.Object3D | null);
+    /**
+     * Finds the maximum original texture resolution from meshes in the scene
+     */
+    getSceneMaxTextureSize(): {
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * Exports high-definition screenshot of the current view.
+     * Supports 'original' / originalQuality which aligns directly to the model's actual texture resolution!
+     */
+    exportImage(options?: ExportImageOptions): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,121 @@
+import * as THREE from 'three';
+export type CameraView = 'front' | 'back' | 'left' | 'right' | 'top' | 'bottom' | 'isometric' | 'isometric-back';
+export type MeasurementType = 'distance' | 'area' | 'height' | 'angle' | 'none';
+export type AutoRotateAxis = 'x' | 'y';
+export type AutoRotateDirection = 'clockwise' | 'counter-clockwise';
+export type RotationLockAxis = 'x' | 'y' | 'z' | null;
+export interface AutoRotateOptions {
+    enabled: boolean;
+    axis: AutoRotateAxis;
+    direction: AutoRotateDirection;
+    speed: number;
+}
+export type ClippingAxis = 'x' | 'y' | 'z';
+export interface ViewerOptions {
+    container: HTMLElement;
+    background?: string | number | null;
+    alpha?: boolean;
+    antialias?: boolean;
+    cameraFov?: number;
+    cameraNear?: number;
+    cameraFar?: number;
+    showBoundingBox?: boolean;
+    unit?: string;
+    controlsType?: 'trackball' | 'orbit';
+}
+export interface ModelLoadResult {
+    model: THREE.Group;
+    box: THREE.Box3;
+    size: THREE.Vector3;
+    center: THREE.Vector3;
+    vertexCount: number;
+    faceCount: number;
+}
+export interface MeasurementResult {
+    id: string;
+    type: MeasurementType;
+    value: number;
+    formattedValue: string;
+    unit: string;
+    points: THREE.Vector3[];
+    extra?: {
+        horizontalDistance?: number;
+        verticalHeight?: number;
+        angleDegree?: number;
+        area?: number;
+    };
+}
+export interface ExportImageOptions {
+    scale?: number | 'original';
+    originalQuality?: boolean;
+    targetSize?: {
+        width: number;
+        height: number;
+    };
+    modelOnly?: boolean;
+    type?: 'image/png' | 'image/jpeg';
+    quality?: number;
+    download?: boolean;
+    filename?: string;
+    background?: string | null;
+}
+export interface ClippingOptions {
+    axis?: ClippingAxis;
+    value?: number;
+    inverted?: boolean;
+}
+export interface ClippingChangeEvent {
+    axis?: ClippingAxis;
+    position?: number;
+    progress?: number;
+    inverted?: boolean;
+    enabled?: boolean;
+    axisClipping?: Record<ClippingAxis, number>;
+    customPlaneActive?: boolean;
+}
+export interface AxisSectionState {
+    enabled: boolean;
+    inverted: boolean;
+    progress: number;
+    position: number;
+}
+export interface SectioningState {
+    enabled: boolean;
+    axes: Record<ClippingAxis, AxisSectionState>;
+    helperVisible: boolean;
+    axis?: ClippingAxis;
+    isReverse?: boolean;
+    progress?: number;
+    position?: number;
+}
+export type ModelDisplayStyle = 'solid' | 'wireframe';
+export interface PointsOptions {
+    size?: number;
+    color?: string | number;
+    sizeAttenuation?: boolean;
+    opacity?: number;
+}
+export interface BoundingBoxOptions {
+    visible: boolean;
+    showDimensions?: boolean;
+    color?: string | number;
+    unit?: string;
+}
+export type ViewerEvents = {
+    'load:start': (url: string | File) => void;
+    'load:progress': (progress: number, message: string) => void;
+    'load:success': (result: ModelLoadResult) => void;
+    'load:error': (error: Error) => void;
+    'measure:start': (type: MeasurementType) => void;
+    'measure:change': (points: THREE.Vector3[]) => void;
+    'measure:complete': (result: MeasurementResult) => void;
+    'measure:clear': () => void;
+    'clipping:change': (info: ClippingChangeEvent) => void;
+    'sectioning:change': (state: SectioningState) => void;
+    'view:change': (view: CameraView) => void;
+    'texture:toggle': (hasTexture: boolean) => void;
+    'autorotate:change': (options: AutoRotateOptions) => void;
+    'axislock:change': (lockedAxis: RotationLockAxis) => void;
+    'style:change': (style: ModelDisplayStyle) => void;
+    'pointsize:change'?: (size: number) => void;
+};

package/dist/utils/math.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from 'three';
+/**
+ * Calculates the exact signed volume of a 3D Mesh using divergence theorem.
+ * Works accurately for closed (watertight) meshes.
+ */
+export declare function computeMeshVolume(mesh: THREE.Mesh): number;
+/**
+ * Computes the total volume of all meshes inside a Group or Object3D
+ */
+export declare function computeGroupVolume(root: THREE.Object3D): {
+    meshVolume: number;
+    bboxVolume: number;
+};
+/**
+ * Calculates the area of a 3D polygon defined by an array of 3D vertices using Newell's method.
+ */
+export declare function compute3DPolygonArea(points: THREE.Vector3[]): number;
+/**
+ * Formats numeric value with unit
+ */
+export declare function formatUnit(value: number, unit?: string, decimals?: number): string;

package/dist/utils/snapping.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+export interface SnapResult {
+    hit: boolean;
+    point: THREE.Vector3 | null;
+    normal: THREE.Vector3 | null;
+    isVertexSnapped: boolean;
+    distanceToVertex: number;
+}
+/**
+ * Finds intersection on model and optionally snaps to the nearest vertex
+ * of the intersected face if within the screen-space pixel threshold.
+ */
+export declare function findSnapPoint(mouse: THREE.Vector2, // Normalized Device Coordinates (-1 to 1)
+camera: THREE.Camera, modelMeshes: THREE.Mesh[], snapPixelThreshold?: number, viewportWidth?: number, viewportHeight?: number): SnapResult;

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@giszhc/three-model-viewer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "A modern, professional 3D model inspector and viewer SDK for Web applications. Features OBJ/MTL/ZIP loading, 3D measurements, dynamic dimensional bounding box, plane slicing, and high-res export.",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "unpkg": "./dist/index.umd.js",
+  "jsdelivr": "./dist/index.umd.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.umd.js"
+    },
+    "./style.css": "./dist/style.css"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "three",
+    "threejs",
+    "model-viewer",
+    "obj",
+    "mtl",
+    "zip",
+    "measurement",
+    "clipping",
+    "bounding-box",
+    "cad-viewer",
+    "3d"
+  ],
+  "author": "giszhc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/giszhc/three-model-viewer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/giszhc/three-model-viewer/issues"
+  },
+  "homepage": "https://github.com/giszhc/three-model-viewer#readme",
+  "type": "module",
+  "dependencies": {
+    "@tweenjs/tween.js": "^25.0.0",
+    "gsap": "^3.15.0",
+    "jszip": "^3.10.2",
+    "three": "^0.186.1",
+    "three-mesh-bvh": "^0.9.16"
+  },
+  "devDependencies": {
+    "@types/three": "^0.186.0",
+    "typescript": "^5.8.2",
+    "vite": "^8.3.5",
+    "vite-plugin-dts": "^5.1.2"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build:lib": "vite build",
+    "build:cdn": "vite build --mode cdn",
+    "build": "vite build && vite build --mode cdn",
+    "build:demo": "vite build --mode demo",
+    "preview": "vite preview",
+    "preview:demo": "vite preview --outDir dist-demo"
+  }
 }