@gcode-viewer/plugins 0.3.0

package/dist/types/property/PropertyPlugin.d.ts

@@ -0,0 +1,95 @@
+import { Viewer3d, Plugin, PluginConfig, THREE } from "@gcode-viewer/core";
+import { BasePanel } from "@gcode-viewer/ui";
+import { captureSceneMaterialSnapshot } from "../scene-edit/SceneMeshSnapshotUtils";
+import { captureSceneTransformState } from "../scene-edit/commands/TransformSceneObjectCommand";
+/**
+ * Tree view plugin config.
+ */
+export interface PropertyPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Container div id.
+     */
+    containerId?: string;
+    /**
+     * If panel is visible. It is visible by default.
+     */
+    visible?: boolean;
+}
+/**
+ * Tree view plugin events.
+ */
+type PropertyPluginEvents = {
+    /**
+     * Panel visibility change event.
+     */
+    visibilitychange: boolean;
+};
+/**
+ * Tree view plugin.
+ */
+export declare class PropertyPlugin extends Plugin<PropertyPluginEvents> {
+    static readonly DEFAULT_ID = "PropertyPlugin";
+    protected cfg: PropertyPluginConfig;
+    protected basePanel?: BasePanel;
+    protected container?: HTMLDivElement;
+    protected content?: HTMLDivElement;
+    protected details?: HTMLDivElement;
+    protected selectedObject: THREE.Object3D | undefined;
+    protected lastActiveTabIdx: number;
+    protected nodePanel?: HTMLDivElement;
+    /** Camera / light / animation blocks; cleared on each {@link renderNode}. */
+    protected nodeExtrasContainer?: HTMLDivElement;
+    protected nodeModeButtons?: {
+        local: HTMLButtonElement;
+        global: HTMLButtonElement;
+    };
+    protected nodeInputs?: {
+        translation: HTMLInputElement[];
+        rotation: HTMLInputElement[];
+        scale: HTMLInputElement[];
+    };
+    protected geometrySection?: HTMLDivElement;
+    protected boundingBoxSection?: HTMLDivElement;
+    protected boundingBoxGeometrySizeInputs?: [HTMLInputElement, HTMLInputElement, HTMLInputElement];
+    protected boundingBoxSizeInputs?: [HTMLInputElement, HTMLInputElement, HTMLInputElement];
+    /** Multi-material Material tab: selected slot index (clamped when re-rendering). */
+    protected materialSlotIndex: number;
+    /** Reset material slot when the highlighted mesh changes. */
+    protected materialPanelMeshUuid?: string;
+    /** Transform state captured when editing Node TRS fields (undo). */
+    protected propertyTransformBefore?: ReturnType<typeof captureSceneTransformState>;
+    /** Material snapshot for debounced undo while editing the Material tab. */
+    protected materialEditBefore?: ReturnType<typeof captureSceneMaterialSnapshot>;
+    protected materialEditDebounce?: ReturnType<typeof setTimeout>;
+    constructor(viewer: Viewer3d, cfg?: PropertyPluginConfig);
+    private onLanguageChange;
+    protected applyLocalizedChrome(): void;
+    protected updateContent(): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    protected onObjectSelected: () => void;
+    protected onObjectDeselected: () => void;
+    protected onObjectTransformed: (object: THREE.Object3D) => void;
+    destroy(): void;
+    protected addContent(): void;
+    /**
+     * Selection can be a {@link THREE.Group} or other {@link THREE.Object3D}; the material panel
+     * needs a concrete {@link THREE.Mesh}. Uses the first visible mesh in subtree (depth-first).
+     */
+    private resolveMeshForMaterialPanel;
+    renderTab(idx: number): void;
+    private scheduleMaterialUndoRecord;
+    private syncOriginalMaterialAfterDuplicate;
+    private renderEnvironment;
+    private renderNode;
+    protected updateNodeInputs(target: THREE.Object3D): void;
+    protected applyNodeInputs(target: THREE.Object3D): void;
+    private appendGeometryAttrRow;
+    private openGeometryAttributeViewer;
+    private appendMeshToolButton;
+    private runRecordedGeometryEdit;
+    private updateMeshTools;
+    private updateGeometryInfo;
+    private updateBoundingBoxInfo;
+}
+export {};

package/dist/types/property/Utils.d.ts

@@ -0,0 +1,19 @@
+import { THREE } from "@gcode-viewer/core";
+/** Backing array length for a buffer attribute (handles interleaved buffers). */
+export declare function getBufferAttributeArrayLength(attr: THREE.BufferAttribute | undefined): number;
+export declare function getGeometrySize(geometry: THREE.BufferGeometry): {
+    width: number;
+    height: number;
+    length: number;
+};
+export declare function getGlobalSize(target: THREE.Object3D): {
+    width: number;
+    height: number;
+    length: number;
+};
+type ReadableBufferAttribute = THREE.BufferAttribute | THREE.InterleavedBufferAttribute;
+/** Formats buffer attribute rows as space-separated components (one row per vertex). */
+export declare function formatBufferAttributeValues(attr: ReadableBufferAttribute, maxRows?: number): string;
+/** Formats geometry index buffer values (one index per line). */
+export declare function formatGeometryIndexValues(index: THREE.BufferAttribute, maxRows?: number): string;
+export {};

package/dist/types/property/Vec3Field.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Three side-by-side number fields, each with a short leading caption (e.g. X/Y/Z, R/G/B, or any strings).
+ */
+export type Vec3FieldOptions = {
+    /** Caption shown before each value (three slots). */
+    labels: readonly [string, string, string];
+    /** When true, values are display-only (`readOnly` inputs, muted styling). */
+    readOnly?: boolean;
+    onChange?: () => void;
+    /** Passed to each `<input type="number">` when set. */
+    step?: string;
+};
+export type Vec3Field = {
+    root: HTMLDivElement;
+    inputs: [HTMLInputElement, HTMLInputElement, HTMLInputElement];
+};
+/**
+ * One slot with the same DOM/classes as each column in {@link createVec3Field}
+ * (`prop-vec3-field__slot` + label strip + `prop-vec3-field__input`).
+ * Caller configures the input (step, disabled, listeners); this only builds the shell.
+ */
+export declare function createVec3StyleSlot(label: string, input: HTMLInputElement): HTMLDivElement;
+/** Same shell as {@link createVec3StyleSlot} but for a `<select>` (texture enums, etc.). */
+export declare function createVec3StyleSelectSlot(label: string, select: HTMLSelectElement): HTMLDivElement;
+export declare function createVec3Field(options: Vec3FieldOptions): Vec3Field;

package/dist/types/property/index.d.ts

@@ -0,0 +1,2 @@
+import "./Property.scss";
+export * from "./PropertyPlugin";

package/dist/types/rhino-3dm-loader/Rhino3dmLoaderPlugin.d.ts

@@ -0,0 +1,17 @@
+import { BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+export interface Rhino3dmLoaderPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Folder URL containing `rhino3dm.js` and `rhino3dm.wasm` (trailing `/` optional).
+     * Default: jsDelivr `rhino3dm@8.17.0`.
+     */
+    libraryPath?: string;
+}
+/**
+ * Registers a `.3dm` model loader using three.js `Rhino3dmLoader` (3DMLoader) + rhino3dm wasm.
+ */
+export declare class Rhino3dmLoaderPlugin extends Plugin {
+    static readonly DEFAULT_ID = "Rhino3dmLoaderPlugin";
+    private readonly loader;
+    constructor(viewer: BaseViewer, cfg?: Rhino3dmLoaderPluginConfig);
+    destroy(): void;
+}

package/dist/types/rhino-3dm-loader/Rhino3dmModelLoader.d.ts

@@ -0,0 +1,25 @@
+import { BaseModelLoader, THREE, type ModelLoadContext, type ModelLoadFromBufferContext } from "@gcode-viewer/core";
+/** Default folder on a CDN; must end with `/` and contain `rhino3dm.js` + `rhino3dm.wasm`. */
+export declare const DEFAULT_RHINO3DM_LIBRARY_PATH = "https://cdn.jsdelivr.net/npm/rhino3dm@8.17.0/";
+export interface Rhino3dmModelLoaderOptions {
+    /** Overrides {@link DEFAULT_RHINO3DM_LIBRARY_PATH} for this instance. */
+    libraryPath?: string;
+    /** Optional Three.js loading manager (e.g. blob URL rewriting). */
+    manager?: THREE.LoadingManager;
+}
+export declare class Rhino3dmModelLoader extends BaseModelLoader {
+    readonly id = "loader.plugin.rhino3dm";
+    readonly priority = 10;
+    readonly formats: readonly ["3dm"];
+    private static defaultLibraryPath;
+    private readonly libraryPath;
+    private readonly manager?;
+    /**
+     * Override the default rhino3dm library folder for all new loaders (unless overridden per instance).
+     */
+    static setLibraryPath(path: string): void;
+    constructor(options?: Rhino3dmModelLoaderOptions);
+    load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
+    loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
+    private applyRequestHeader;
+}

package/dist/types/rhino-3dm-loader/index.d.ts

@@ -0,0 +1 @@
+export { Rhino3dmLoaderPlugin, type Rhino3dmLoaderPluginConfig } from "./Rhino3dmLoaderPlugin";

package/dist/types/scene-edit/SceneEditActions.d.ts

@@ -0,0 +1,24 @@
+import type { UndoManager, Viewer3d, THREE } from "@gcode-viewer/core";
+/**
+ * Scene graph edit operations for CAD mode ({@link Viewer3d.enableSceneEditing}).
+ * Pushes {@link Command}s to the viewer's single {@link UndoManager} stack.
+ */
+export declare class SceneEditActions {
+    private readonly viewer;
+    private readonly undoManager;
+    private clipboard?;
+    constructor(viewer: Viewer3d, undoManager: UndoManager);
+    hasClipboard(): boolean;
+    copySelection(): boolean;
+    pasteSelection(): boolean;
+    duplicateNode(node: THREE.Object3D): boolean;
+    private insertClone;
+    private resolvePastePlacement;
+    private isModelRoot;
+    deleteSelection(): boolean;
+    /**
+     * Re-parents {@link object} under {@link newParent} at {@link targetIndex}.
+     * Records undo when the scene graph actually changes.
+     */
+    reparentSceneNode(object: THREE.Object3D, newParent: THREE.Object3D, targetIndex: number): boolean;
+}

package/dist/types/scene-edit/SceneEditPlugin.d.ts

@@ -0,0 +1,26 @@
+import { Plugin, type BaseViewer, type PluginConfig } from "@gcode-viewer/core";
+import { SceneEditActions } from "./SceneEditActions";
+export interface SceneEditPluginConfig extends Partial<PluginConfig> {
+    /** When false, the plugin does not register shortcuts (viewer may still expose API). */
+    enabled?: boolean;
+}
+/**
+ * CAD scene-editing shortcuts when {@link Viewer3dConfig.enableSceneEditing} is on.
+ * Uses the viewer's single {@link UndoManager} stack (shared with measurements).
+ */
+export declare class SceneEditPlugin extends Plugin {
+    static readonly DEFAULT_ID = "SceneEditPlugin";
+    private readonly viewer3d;
+    private readonly cfg;
+    private readonly actions;
+    private enabled;
+    private gizmoTransformBefore?;
+    private readonly onKeyDown;
+    constructor(viewer: BaseViewer, cfg?: SceneEditPluginConfig);
+    getSceneEditActions(): SceneEditActions;
+    private shouldDeferToOverlay;
+    private onGizmoDragStart;
+    private onGizmoDragEnd;
+    setEnabled(enable: boolean): void;
+    destroy(): void;
+}

package/dist/types/scene-edit/SceneEditRecording.d.ts

@@ -0,0 +1,11 @@
+import type { THREE, Viewer3d } from "@gcode-viewer/core";
+import { captureSceneTransformState } from "./commands/TransformSceneObjectCommand";
+/**
+ * Runs {@link mutate} on {@link target} and records undo when scene editing is enabled.
+ * Captures mesh geometry + local TRS before and after the mutation.
+ */
+export declare function recordGeometryEdit(viewer: Viewer3d, target: THREE.Object3D, mutate: () => void): boolean;
+/** Records undo for material changes on meshes under {@link target}. */
+export declare function recordMaterialEdit(viewer: Viewer3d, target: THREE.Object3D, mutate: () => void): boolean;
+/** Pushes a transform undo command when before/after differ. */
+export declare function recordTransformEdit(viewer: Viewer3d, object: THREE.Object3D, before: ReturnType<typeof captureSceneTransformState>): void;

package/dist/types/scene-edit/SceneMeshSnapshot.d.ts

@@ -0,0 +1,23 @@
+import type { THREE } from "@gcode-viewer/core";
+/** Per-mesh geometry + local TRS captured for undo/redo of mesh-level edits. */
+export interface MeshGeometrySnapshot {
+    meshUuid: string;
+    geometry: THREE.BufferGeometry | null;
+    position: THREE.Vector3;
+    rotation: THREE.Euler;
+    scale: THREE.Vector3;
+}
+/** Snapshot of all drawable meshes under a subtree root. */
+export interface SceneMeshSnapshot {
+    rootUuid: string;
+    meshes: MeshGeometrySnapshot[];
+}
+/** Per-mesh material assignment for undo/redo. */
+export interface MeshMaterialSnapshot {
+    meshUuid: string;
+    material: THREE.Material | THREE.Material[];
+}
+export interface SceneMaterialSnapshot {
+    rootUuid: string;
+    meshes: MeshMaterialSnapshot[];
+}

package/dist/types/scene-edit/SceneMeshSnapshotUtils.d.ts

@@ -0,0 +1,11 @@
+import { THREE } from "@gcode-viewer/core";
+import type { Viewer3d } from "@gcode-viewer/core";
+import type { SceneMaterialSnapshot, SceneMeshSnapshot } from "./SceneMeshSnapshot";
+/** Captures geometry clones and local TRS for every drawable mesh under {@link root}. */
+export declare function captureSceneMeshSnapshot(root: THREE.Object3D): SceneMeshSnapshot;
+/** Restores mesh geometry and local TRS from {@link snapshot}. */
+export declare function applySceneMeshSnapshot(viewer: Viewer3d, snapshot: SceneMeshSnapshot): boolean;
+/** Captures material references (cloned) for meshes under {@link root}. */
+export declare function captureSceneMaterialSnapshot(root: THREE.Object3D): SceneMaterialSnapshot;
+/** Restores mesh materials from {@link snapshot}. */
+export declare function applySceneMaterialSnapshot(viewer: Viewer3d, snapshot: SceneMaterialSnapshot): boolean;

package/dist/types/scene-edit/SceneNodeSnapshot.d.ts

@@ -0,0 +1,7 @@
+import type { THREE } from "@gcode-viewer/core";
+/** Captured state to undo {@link Viewer3d.removeSceneObject} for a subtree node. */
+export interface SceneNodeSnapshot {
+    detachedClone: THREE.Object3D;
+    parentUuid: string;
+    childIndex: number;
+}

package/dist/types/scene-edit/SceneNodeSnapshotUtils.d.ts

@@ -0,0 +1,11 @@
+import { Model3d, type THREE, type Viewer3d } from "@gcode-viewer/core";
+import type { SceneNodeSnapshot } from "./SceneNodeSnapshot";
+export declare function isSceneModelRoot(object: THREE.Object3D): boolean;
+/** Finds the {@link Model3d} that owns {@link object} in the scene graph. */
+export declare function findModel3dOwning(viewer: Viewer3d, object: THREE.Object3D): Model3d | undefined;
+/** @deprecated Use {@link findModel3dOwning}. */
+export declare function findModel3dForSceneRoot(viewer: Viewer3d, object: THREE.Object3D): Model3d | undefined;
+/** Whether deleting {@link object} should remove the entire loaded model (tree root / model wrapper). */
+export declare function isWholeModelDeleteTarget(object: THREE.Object3D, model: Model3d): boolean;
+/** Builds a snapshot for undoing removal of a non-model-root node. */
+export declare function createSceneNodeSnapshot(object: THREE.Object3D): SceneNodeSnapshot | undefined;

package/dist/types/scene-edit/commands/GeometryEditCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command, type Viewer3d } from "@gcode-viewer/core";
+import type { SceneMeshSnapshot } from "../SceneMeshSnapshot";
+export declare class GeometryEditCommand extends Command {
+    private readonly viewer;
+    private readonly before;
+    private readonly after;
+    constructor(viewer: Viewer3d, before: SceneMeshSnapshot, after: SceneMeshSnapshot);
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/commands/InsertSceneNodeCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command, type Viewer3d } from "@gcode-viewer/core";
+import type { SceneNodeSnapshot } from "../SceneNodeSnapshot";
+/** Undo/redo for insertions (paste, duplicate). */
+export declare class InsertSceneNodeCommand extends Command {
+    private readonly viewer;
+    private readonly snapshot;
+    constructor(viewer: Viewer3d, snapshot: SceneNodeSnapshot);
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/commands/MaterialEditCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command, type Viewer3d } from "@gcode-viewer/core";
+import type { SceneMaterialSnapshot } from "../SceneMeshSnapshot";
+export declare class MaterialEditCommand extends Command {
+    private readonly viewer;
+    private readonly before;
+    private readonly after;
+    constructor(viewer: Viewer3d, before: SceneMaterialSnapshot, after: SceneMaterialSnapshot);
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/commands/MoveSceneNodeCommand.d.ts

@@ -0,0 +1,10 @@
+import { Command, type SceneNodePlacement, type Viewer3d } from "@gcode-viewer/core";
+export declare class MoveSceneNodeCommand extends Command {
+    private readonly viewer;
+    private readonly objectUuid;
+    private readonly before;
+    private readonly after;
+    constructor(viewer: Viewer3d, objectUuid: string, before: SceneNodePlacement, after: SceneNodePlacement);
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/commands/RemoveSceneObjectCommand.d.ts

@@ -0,0 +1,9 @@
+import { Command, type Viewer3d } from "@gcode-viewer/core";
+import type { SceneNodeSnapshot } from "../SceneNodeSnapshot";
+export declare class RemoveSceneObjectCommand extends Command {
+    private readonly viewer;
+    private readonly snapshot;
+    constructor(viewer: Viewer3d, snapshot: SceneNodeSnapshot);
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/commands/TransformSceneObjectCommand.d.ts

@@ -0,0 +1,17 @@
+import { Command, THREE, type Viewer3d } from "@gcode-viewer/core";
+export interface SceneTransformState {
+    objectUuid: string;
+    position: THREE.Vector3;
+    rotation: THREE.Euler;
+    scale: THREE.Vector3;
+}
+export declare function captureSceneTransformState(object: THREE.Object3D): SceneTransformState;
+export declare class TransformSceneObjectCommand extends Command {
+    private readonly viewer;
+    private readonly before;
+    private readonly after;
+    constructor(viewer: Viewer3d, before: SceneTransformState, after: SceneTransformState);
+    static shouldRecord(before: SceneTransformState, after: SceneTransformState): boolean;
+    undo(): boolean;
+    redo(): boolean;
+}

package/dist/types/scene-edit/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./SceneEditPlugin";
+export * from "./SceneEditActions";
+export * from "./SceneNodeSnapshot";
+export * from "./SceneNodeSnapshotUtils";
+export * from "./SceneMeshSnapshot";
+export * from "./SceneMeshSnapshotUtils";
+export * from "./SceneEditRecording";
+export * from "./commands/InsertSceneNodeCommand";
+export * from "./commands/GeometryEditCommand";
+export * from "./commands/MaterialEditCommand";
+export * from "./commands/RemoveSceneObjectCommand";
+export * from "./commands/MoveSceneNodeCommand";
+export * from "./commands/TransformSceneObjectCommand";

package/dist/types/screenshot/ScreenshotPlugin.d.ts

@@ -0,0 +1,134 @@
+import { THREE } from "@gcode-viewer/core";
+import { type BaseViewer, BoxSelectHelper, PickMarkupHelper, Plugin, PluginConfig } from "@gcode-viewer/core";
+/**
+ * Screenshot mode.
+ */
+export declare enum ScreenshotMode {
+    /**
+     * Take screenshot of the whole canvas.
+     */
+    Default = "Default",
+    /**
+     * Take screenshot by box selecting an area.
+     */
+    BoxSelection = "BoxSelection",
+    /**
+     * Take screenshot by picking a markup.
+     */
+    PickMarkup = "PickMarkup"
+}
+/**
+ * Screenshot plugin config.
+ */
+export interface ScreenshotPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Image type.
+     */
+    type?: "image/png" | "image/jpg";
+    /**
+     * Image quality.
+     */
+    quality?: number;
+    /**
+     * Sets background transparent, this must be used for "image/png" format.
+     * @default false
+     * @hidden
+     */
+    setBackgroundTransparent?: boolean;
+}
+/**
+ * Screenshot result, which contains a result image and,
+ * for Viewer3d, it contains the camera's position and target.
+ */
+export interface ScreenshotResult {
+    /**
+     * The view extent when the screenshot is taken.
+     * Note that, it is not the image's extent.
+     */
+    viewExtent?: THREE.Box2;
+    /**
+     * Used for Viewer3d
+     * @hidden
+     */
+    /**
+     * Used for Viewer3d
+     * @hidden
+     */
+    /**
+     * Image type, which is "image/png" by default
+     * @hidden
+     */
+    imageType: string;
+    /**
+     * The image, in base 64 format.
+     */
+    base64Image: string;
+}
+/**
+ * Screenshot plugin
+ */
+export declare class ScreenshotPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ScreenshotPlugin";
+    protected cfg: ScreenshotPluginConfig;
+    protected boxSelectHelper?: BoxSelectHelper;
+    protected pickMarkupHelper?: PickMarkupHelper;
+    protected originalBackground: THREE.Color | undefined;
+    protected originalClearAlpha: number;
+    constructor(viewer: BaseViewer, cfg?: ScreenshotPluginConfig);
+    /**
+     * Captures the WebGL canvas as a data URL (base64 image string).
+     * @example
+     * ``` typescript
+     * const plugin = new ScreenshotPlugin(viewer);
+     * const base64Image = plugin.getScreenshot();
+     * console.log(base64Image);
+     * ```
+     */
+    getScreenshot(): string | undefined;
+    /**
+     * Gets screenshot by bbox under screen cooridinate.
+     */
+    getScreenshotByScreenBBox(bbox: THREE.Box2): Promise<string | undefined>;
+    /**
+     * Gets a screenshot for world-space bounds clipped to the current viewport (screen overlap only).
+     * It needs to convert world to screen coordinate, in order to get the
+     * screenshot range. Assume it maps to bboxA under screen coordinate,
+     * and current view boundary is bboxB (e.g., 0,0 - 1024,768).
+     * Since, a given world coordinate may not be in current view boundary.
+     * The finally screenshot is the overlap of bboxA and bboxB. When
+     * - bboxA includes bboxB, it get screenshot for bboxB
+     * - bboxB includes bboxA, it get screenshot for bboxA
+     * - bboxA overlaps with bboxB, it get screenshot for the overlapped area
+     * - bboxA doesn't overlap with bboxB, it get nothing
+     *
+     * A best practice to use this API is to use orthographic camera, under top view,
+     * and pass in viewer's bbox.
+     */
+    getScreenshotForWorldBoundsInViewport(bbox: THREE.Box3): Promise<string | undefined>;
+    /**
+     * Async screenshot: full view, user box selection, or pick-a-markup region; returns base64 image data.
+     * @param mode `Default` (full view), `BoxSelection`, or `PickMarkup`.
+     * @example
+     * ``` typescript
+     * // Pick a markup to define the crop region.
+     * const mode = ScreenshotMode.PickMarkup;
+     * viewer.getScreenshot(mode).then(data => console.log(data));
+     * // User draws a rectangle on screen.
+     * const mode = ScreenshotMode.BoxSelection;
+     * viewer.getScreenshot(mode).then(data => console.log(data));
+     * // Entire current view.
+     * const mode = ScreenshotMode.Default;
+     * const plugin = new ScreenshotPlugin(viewer);
+     * plugin.getScreenshotAsync(mode).then(data => console.log(data));
+     * ```
+     */
+    getScreenshotAsync(mode?: ScreenshotMode): Promise<undefined | ScreenshotResult>;
+    /**
+     * If ScreenshotPlugin is active.
+     */
+    isActive(): (() => boolean) | undefined;
+    /**
+     * Cancel current operation if any.
+     */
+    cancel(): void;
+}

package/dist/types/screenshot/index.d.ts

@@ -0,0 +1 @@
+export * from "./ScreenshotPlugin";

package/dist/types/sections/AxisPlaneSection.d.ts

@@ -0,0 +1,65 @@
+import { THREE } from "@gcode-viewer/core";
+import { EventInfo, InputManager, type BaseViewer } from "@gcode-viewer/core";
+import { BaseSection } from "./BaseSection";
+import { SectionGizmo } from "../sections/SectionGizmo";
+import { SectionPlaneMesh } from "../sections/SectionPlaneMesh";
+export declare enum AxisType {
+    X = "X",
+    Y = "Y",
+    Z = "Z"
+}
+export declare class AxisPlaneSection extends BaseSection {
+    protected activeAxis: AxisType;
+    protected gizmo?: SectionGizmo;
+    protected planeMesh?: SectionPlaneMesh;
+    protected capsWireframe?: SectionPlaneMesh;
+    protected clipPlane?: THREE.Plane;
+    protected selectedObject?: SectionPlaneMesh | THREE.Mesh | THREE.Object3D;
+    protected axisInfoMap: {
+        [key in AxisType]: {
+            normal: THREE.Vector3;
+        };
+    };
+    protected center: THREE.Vector3;
+    protected clipPlaneConstant?: number;
+    constructor(viewer: BaseViewer, input: InputManager);
+    /**
+     * Activates plane section.
+     * @param type Specifies the axis for sectioning. The default value is "X" axis.
+     * @param clipPlaneConstant It decides where the clip plane is. By default, the clip plane passes through
+     * the center of world bounding box. Caller can specify a different position.
+     * E.g., when type is "X" and clipPlaneConstant is 10, it means the clip plane passes through (10, 0, 0).
+     */
+    activate(type?: AxisType, clipPlaneConstant?: number): void;
+    deactivate(keepSectionState?: boolean): void;
+    reset(): void;
+    /**
+     * Sets a AxisType for plane section.
+     * @param type Specifies the axis for sectioning.
+     * @param clipPlaneConstant It decides where the clip plane is. By default, the clip plane passes through
+     * the center of world bounding box. Caller can specify a different position.
+     * E.g., when type is "X" and clipPlaneConstant is 10, it means the clip plane passes through (10, 0, 0).
+     */
+    setActiveAxis(type: AxisType, clipPlaneConstant?: number): void;
+    /**
+     * Sets gizmo and section plane mesh visibility.
+     */
+    setSectionPlaneVisible(visible: boolean): void;
+    protected initOrUpdateClipPlanes(): void;
+    protected initOrUpdateSectionPlaneMeshes(): void;
+    private createCapsWireframe;
+    protected applyCapsMaterial(): void;
+    setCapsVisible(visible: boolean): void;
+    protected initOrUpdateGizmo(): void;
+    mousedown: (e: EventInfo) => void;
+    protected mousemove: (e: EventInfo) => void;
+    onDragStart(e: EventInfo): void;
+    onDragMove(e: EventInfo): void;
+    onDragEnd(e: EventInfo): void;
+    getIntersectObjects(): THREE.Object3D[];
+    activateSelectedObject(active: boolean): void;
+    /**
+     * Adjusts a position by activeAxis and clipPlaneConstant.
+     */
+    private adjustPositionByClipPlaneConstant;
+}

package/dist/types/sections/AxisSectionPopPanel.d.ts

@@ -0,0 +1,18 @@
+import { type BaseViewer } from "@gcode-viewer/core";
+import { PopPanel } from "@gcode-viewer/ui";
+import { AxisPlaneSection } from "./AxisPlaneSection";
+export declare class AxisSectionPopPanel extends PopPanel {
+    protected axis: string;
+    protected activeItem?: string;
+    protected groupSelectNode?: HTMLElement;
+    protected activeSelectNode?: HTMLElement;
+    protected isVisible: boolean;
+    protected section: AxisPlaneSection;
+    constructor(viewer: BaseViewer);
+    keydown: (e: KeyboardEvent) => void;
+    destroy(): void;
+    createGroupSelectLayout(): void;
+    addGroupSelectItems(): void;
+    createActiveSelectLayout(): void;
+    addActiveItems(): void;
+}