@gcode-viewer/plugins 0.3.0

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

@@ -0,0 +1,64 @@
+import { THREE } from "@gcode-viewer/core";
+import { EventInfo, InputManager, type BaseViewer } from "@gcode-viewer/core";
+/**
+ * Abstract base class for AxisPlaneSection, ObjectsBoxSection, etc.
+ */
+export declare abstract class BaseSection {
+    protected viewer: BaseViewer;
+    protected inputManager: InputManager;
+    protected scene: THREE.Scene;
+    protected renderer: THREE.WebGLRenderer;
+    protected raycaster: THREE.Raycaster;
+    protected sectionBox: THREE.Box3;
+    protected lastWorldPos: THREE.Vector3;
+    protected mouseMoved: boolean;
+    protected dragStarted: boolean;
+    protected clipPlanes?: THREE.Plane[];
+    protected vertices?: THREE.Vector3[];
+    protected selectedObject?: THREE.Object3D;
+    protected refrencePlane: THREE.Plane;
+    protected active: boolean;
+    protected capsVisibility: boolean;
+    protected capsMaterial?: THREE.Material;
+    /**
+     * If to show section plane and gizmo or not.
+     */
+    showSectionPlane: boolean;
+    capsScene: THREE.Scene;
+    /**
+     * @hidden
+     */
+    clippingObjetIds?: number[];
+    constructor(viewer: BaseViewer, input: InputManager);
+    protected get canvas(): HTMLCanvasElement;
+    get isActive(): boolean;
+    protected get camera(): THREE.Camera;
+    private setGlobalClippingEnabled;
+    private setObjectClippingEnabled;
+    clearClippingObjectIds(): void;
+    setClippingEnabled(enable: boolean): void;
+    activate(): void;
+    deactivate(keepSectionState?: boolean): void;
+    setCapsVisible(visible: boolean): void;
+    getCapsVisible(): boolean;
+    setCapsMaterial(material: THREE.Material): void;
+    protected applyCapsMaterial(): void;
+    protected getCapsMaterial(): THREE.Material<THREE.MaterialEventMap> | undefined;
+    protected setControlsEnabled(enable: boolean): void;
+    protected mousedown: (e: EventInfo) => void;
+    protected mousemove: (e: EventInfo) => void;
+    protected mouseup: (e: EventInfo) => void;
+    protected keydown: (e: EventInfo) => void;
+    protected getIntersection(e: EventInfo): THREE.Intersection | undefined;
+    protected updateRaycasterByMouse(e: EventInfo): void;
+    destroy(): void;
+    protected abstract onDragStart(e: EventInfo): void;
+    protected abstract onDragMove(e: EventInfo): void;
+    protected abstract onDragEnd(e: EventInfo): void;
+    protected abstract getIntersectObjects(): THREE.Object3D[];
+    protected abstract activateSelectedObject(active: boolean): void;
+    protected abstract initOrUpdateSectionPlaneMeshes(): void;
+    protected abstract initOrUpdateClipPlanes(): void;
+    abstract reset(): void;
+    abstract setSectionPlaneVisible(visible: boolean): void;
+}

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

@@ -0,0 +1,21 @@
+import { i18n } from "@gcode-viewer/core";
+export declare const en: {
+    pickPlaneSection: string;
+    pickSectionPlane: string;
+    axisSection: string;
+    hideSectionPlane: string;
+    showSectionPlane: string;
+    reset: string;
+};
+export declare const zh: {
+    pickPlaneSection: string;
+    pickSectionPlane: string;
+    axisSection: string;
+    hideSectionPlane: string;
+    showSectionPlane: string;
+    reset: string;
+};
+export declare const SECTION_I18N_NAMESPACE: "section";
+export { i18n };
+export type SectionTranslationKey = keyof typeof en;
+export declare function t(key: SectionTranslationKey): string;

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

@@ -0,0 +1,29 @@
+import { THREE, EventInfo, InputManager, ViewDirection, BaseViewer } from "@gcode-viewer/core";
+import { BaseSection } from "./BaseSection";
+import { SectionPlaneMesh } from "./SectionPlaneMesh";
+export declare class ObjectsBoxSection extends BaseSection {
+    protected selectedObject?: SectionPlaneMesh;
+    protected planeMeshes?: SectionPlaneMesh[];
+    protected sectionRange: Record<string, number[]>;
+    private capsWireframes?;
+    constructor(viewer: BaseViewer, input: InputManager);
+    activate(): void;
+    deactivate(keepSectionState?: boolean): void;
+    protected initOrUpdateVertices(): void;
+    protected initOrUpdateClipPlanes(): void;
+    protected initOrUpdateSectionPlaneMeshes(): void;
+    protected initOrUpdateCapsWireframes(): void;
+    protected createCapsWireframe(actionType: ViewDirection, vertices: THREE.Vector3[], clipPlane: THREE.Plane): SectionPlaneMesh;
+    protected applyCapsMaterial(): void;
+    activateSelectedObject(active: boolean): void;
+    onDragStart(e: EventInfo): void;
+    onDragMove(e: EventInfo): void;
+    onDragEnd(e: EventInfo): void;
+    protected dragTranslateSectionPlane(axis: THREE.Vector3, from: THREE.Vector3, to: THREE.Vector3, actionType: ViewDirection): void;
+    protected isInRange(value: number, range: number[]): boolean;
+    protected getIntersection(e: EventInfo): THREE.Intersection | undefined;
+    getIntersectObjects(): SectionPlaneMesh[];
+    reset(): void;
+    setSectionPlaneVisible(visible: boolean): void;
+    setCapsVisible(visible: boolean): void;
+}

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

@@ -0,0 +1,48 @@
+import { THREE, EventInfo, InputManager } from "@gcode-viewer/core";
+import type { BaseViewer } from "@gcode-viewer/core";
+import { Tooltip } from "@gcode-viewer/ui";
+import { BaseSection } from "../sections/BaseSection";
+import { SectionGizmo } from "../sections/SectionGizmo";
+import { SectionPlaneMesh } from "../sections/SectionPlaneMesh";
+export declare class PickPlaneSection extends BaseSection {
+    protected pickedFaceInfo?: {
+        position: THREE.Vector3;
+        normal: THREE.Vector3;
+    };
+    protected gizmo?: SectionGizmo;
+    protected planeMesh?: SectionPlaneMesh;
+    protected capsWireframe?: SectionPlaneMesh;
+    protected clipPlane?: THREE.Plane;
+    protected selectedObject?: SectionPlaneMesh | THREE.Mesh | THREE.Object3D;
+    protected center: THREE.Vector3;
+    protected tooltip?: Tooltip;
+    protected lastMouseMoveIntersection?: THREE.Intersection;
+    private readonly rotationQuat;
+    constructor(viewer: BaseViewer, input: InputManager);
+    activate(): void;
+    deactivate(keepSectionState?: boolean): void;
+    setSection(): void;
+    reset(): void;
+    setSectionPlaneVisible(visible: boolean): void;
+    protected initOrUpdateClipPlanes(): void;
+    protected initOrUpdateSectionPlaneMeshes(): void;
+    private createCapsWireframe;
+    protected applyCapsMaterial(): void;
+    protected initOrUpdateGizmo(): void;
+    mousedown: (e: EventInfo) => void;
+    mousemove: (e: EventInfo) => void;
+    onDragStart(e: EventInfo): void;
+    onDragMove(e: EventInfo): void;
+    /**
+     * Rotate gizmo/section plane/caps with the same world-axis quaternion.
+     */
+    private rotateSectionByAxis;
+    onDragEnd(e: EventInfo): void;
+    getIntersectObjects(): THREE.Object3D[];
+    activateSelectedObject(active: boolean): void;
+    /**
+     * Picks an object by mouse position.
+     */
+    pickObject(e: EventInfo): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | undefined;
+    setCapsVisible(visible: boolean): void;
+}

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

@@ -0,0 +1,18 @@
+import { type BaseViewer } from "@gcode-viewer/core";
+import { PopPanel } from "@gcode-viewer/ui";
+import { PickPlaneSection } from "./PickPlaneSection";
+export declare class PickSectionPopPanel extends PopPanel {
+    protected activeSelectNode?: Element;
+    protected isVisible: boolean;
+    protected enabled: boolean;
+    protected visibleNode?: HTMLElement;
+    protected resetNode?: HTMLElement;
+    protected section: PickPlaneSection;
+    constructor(viewer: BaseViewer);
+    keydown: (e: KeyboardEvent) => void;
+    destroy(): void;
+    createActiveSelectLayout(): void;
+    addActiveItems(): void;
+    enable(): void;
+    disable(): void;
+}

package/dist/types/sections/Section.constants.d.ts

@@ -0,0 +1,13 @@
+import { THREE } from "@gcode-viewer/core";
+export declare const AxisX: THREE.Vector3;
+export declare const AxisY: THREE.Vector3;
+export declare const AxisZ: THREE.Vector3;
+export declare enum ActionType {
+    None = "",
+    TranslateX = "TranslateX",
+    TranslateY = "TranslateY",
+    TranslateZ = "TranslateZ",
+    RotateX = "RotateX",
+    RotateY = "RotateY",
+    RotateZ = "RotateZ"
+}

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

@@ -0,0 +1,22 @@
+import { THREE } from "@gcode-viewer/core";
+import { ActionType } from "../sections/Section.constants";
+export declare class SectionGizmo extends THREE.Group {
+    protected redMaterial: THREE.MeshBasicMaterial;
+    protected greenMaterial: THREE.MeshBasicMaterial;
+    protected blueMaterial: THREE.MeshBasicMaterial;
+    protected highlightMaterial: THREE.MeshBasicMaterial;
+    protected pickableMaterial: THREE.MeshBasicMaterial;
+    protected originalMaterial?: THREE.MeshBasicMaterial;
+    protected hoverObject?: THREE.Mesh;
+    constructor(normal?: THREE.Vector3);
+    initIgnoreClipMaterial(): void;
+    setDirection(normal: THREE.Vector3): void;
+    initOrUpdateByAxis(normal: THREE.Vector3): void;
+    createTranslateGizmo(actionType: ActionType, direction: THREE.Vector3, size: number, material: THREE.Material): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material<THREE.MaterialEventMap>, THREE.Object3DEventMap>;
+    createRotateGizmo(actionType: ActionType, direction: THREE.Vector3, size: number, material: THREE.Material, degree: number): THREE.Mesh<THREE.TorusGeometry, THREE.Material<THREE.MaterialEventMap>, THREE.Object3DEventMap>;
+    createSphere(size: number, material: THREE.Material, position?: THREE.Vector3): void;
+    setActiveAxis(axis: THREE.Vector3): void;
+    private createHoverRotateObjectByAxis;
+    setActive(active: boolean, selectObject: THREE.Mesh): void;
+    adjustSize(camera: THREE.Camera): void;
+}

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

@@ -0,0 +1,23 @@
+import { THREE } from "@gcode-viewer/core";
+/**
+ * Visible section plan mesh.
+ */
+export declare class SectionPlaneMesh extends THREE.Mesh {
+    static readonly normalPlaneColor: THREE.Color;
+    static readonly activePlaneColor: THREE.Color;
+    static readonly normalLineColor = 16777215;
+    actionType: string;
+    vertices: THREE.Vector3[];
+    edge: THREE.Line;
+    wireframe?: THREE.LineSegments;
+    constructor(actionType: string, vertices: THREE.Vector3[]);
+    createIgnoreClipMaterials(material: THREE.Material): void;
+    createEdge(vertices: THREE.Vector3[]): THREE.Line<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.LineBasicMaterial, THREE.Object3DEventMap>;
+    createLine(): void;
+    update(vertices: THREE.Vector3[]): void;
+    rotatePlane(axis: THREE.Vector3, angle: number): void;
+    setDirection(normal: THREE.Vector3): void;
+    getPlaneNormal(): THREE.Vector3;
+    setActive(active: boolean): void;
+    getPlaneCenter(): THREE.Vector3;
+}

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

@@ -0,0 +1,147 @@
+import { PluginConfig, THREE } from "@gcode-viewer/core";
+import { type BaseViewer, Plugin } from "@gcode-viewer/core";
+import { BaseSection } from "../sections/BaseSection";
+/**
+ * Section type
+ */
+export declare enum SectionType {
+    ObjectsBoxSection = "ObjectsBoxSection",
+    PickPlaneSection = "PickPlaneSection",
+    AxisPlaneSection = "AxisPlaneSection"
+}
+/**
+ * Section plugin config.
+ */
+export interface SectionPluginConfig extends Partial<PluginConfig> {
+    capsVisible?: boolean;
+    capsColor?: THREE.ColorRepresentation;
+    /**
+     * Automatically skip non-closed (non-manifold) meshes during the cap
+     * stencil pass. Open meshes such as terrain surfaces, glass panes and
+     * sky domes leave unbalanced back/front fragment counts and otherwise
+     * fill regions that are not really part of the model's cross-section.
+     *
+     * Detection is done per `BufferGeometry` via an edge-share check and the
+     * result is cached on `geometry.userData._sectionCapClosed`. Explicit
+     * overrides via `setSkipSectionCap(mesh, true|false)` always win.
+     *
+     * Defaults to `true`.
+     */
+    autoSkipNonClosedMeshes?: boolean;
+}
+export declare const DEFAULT_CAPS_VISIBLE = true;
+export declare const DEFAULT_CAPS_COLOR = 10265519;
+export declare const DEFAULT_AUTO_SKIP_NON_CLOSED = true;
+/**
+ * Section plugin, can be used by Viewer3d.
+ */
+export declare class SectionPlugin extends Plugin {
+    static readonly DEFAULT_ID = "SectionPlugin";
+    constructor(viewer: BaseViewer, cfg?: SectionPluginConfig);
+    protected get raycaster(): THREE.Raycaster;
+    /**
+     * Activates one of "ObjectsBoxSection", "AxisPlaneSection" or "PickPlaneSection" Section
+     * @param {SectionType} type
+     * @param clippingObjectIds
+     */
+    activate(type: SectionType): void;
+    /**
+     * @description Deactivate Section plugin
+     * @param keepSectionState Keep objects being clipped even after deactived.
+     */
+    deactivate(keepSectionState?: boolean): void;
+    /**
+     * Resets section to initial state.
+     */
+    reset(): void;
+    /**
+     * Sets gizmo and section plane mesh visibility.
+     */
+    setSectionPlaneVisible(visible: boolean): void;
+    /**
+     * Sets section cut opening fill visibility.
+     */
+    setCapsVisible(visible: boolean): void;
+    /**
+     * Gets section cut opening fill visibility.
+     */
+    getCapsVisible(): boolean;
+    /**
+     * Sets section cut opening fill color.
+     */
+    setCapsColor(color: THREE.ColorRepresentation): void;
+    /**
+     * Excludes (or force-includes) a subtree from the section cap stencil
+     * pass.
+     *
+     * Stencil capping relies on each contributing mesh being a closed solid
+     * so that back-/front-face fragment counts cancel outside the cut.
+     * Non-closed meshes (terrain surfaces, glass panes, sky domes, single-
+     * sided floor tiles, ...) otherwise leave a permanent imbalance and
+     * fill regions of the cap that are not really part of the model's
+     * cross-section.
+     *
+     * By default the plugin auto-detects this via an edge-share manifold
+     * test (`autoSkipNonClosedMeshes`). Use this method to override the
+     * decision for a subtree:
+     *  - `skip = true`  → always exclude from the stencil pass.
+     *  - `skip = false` → always include, even if auto-detection would
+     *                     have marked it as non-closed.
+     *  - `skip = "auto"` → clear the override and fall back to auto-detect.
+     */
+    setSkipSectionCap(object: THREE.Object3D, skip?: boolean | "auto"): void;
+    /**
+     * Enables/disables automatic detection of non-closed meshes for the
+     * section cap stencil pass. See `autoSkipNonClosedMeshes` in
+     * `SectionPluginConfig` for details.
+     */
+    setAutoSkipNonClosedMeshes(enabled: boolean): void;
+    /**
+     * Returns the nearest ancestor whose mesh children should be treated as
+     * one logical cap object. By default this is `mesh.parent` (e.g. an
+     * IFC element like `Wall_-_Timber_Clad_<418079>` that contains many
+     * small face quads). The model group root is never returned so that
+     * meshes that sit directly under the root are still tested
+     * individually.
+     */
+    static findCapGroup(mesh: THREE.Object3D, modelRoot?: THREE.Object3D): THREE.Object3D | undefined;
+    /**
+     * Checks whether the union of all `THREE.Mesh` descendants of `group`
+     * forms a closed (edge-manifold) surface. Vertex positions are binned
+     * with a tolerance so that meshes that share a seam by coordinate (the
+     * usual case for IFC→glTF face quads) are correctly stitched.
+     * Result is cached on `group.userData._sectionCapClosed`.
+     */
+    static isGroupClosedManifold(group: THREE.Object3D): boolean;
+    /**
+     *
+     * @returns {boolean} Is Section active
+     */
+    isActive(): boolean;
+    /**
+     * Gets the active section type.
+     */
+    getActiveSectionType(): SectionType | undefined;
+    /**
+     * Gets the active section.
+     */
+    getActiveSection(): BaseSection | undefined;
+    /**
+     * Sets clipping object ids for all sections.
+     * @param ids
+     * @returns
+     * @description Set the id of the object that needs to be clipping for all section
+     */
+    setClippingObjectIds(ids?: number[]): void;
+    /**
+     * Sets clipping object ids for a specific SectionType.
+     * @param ids
+     * @returns
+     * @description Set the id of the object that needs to be clipping for section by section type
+     */
+    setClippingObjectIdsForType(type: SectionType, ids?: number[]): void;
+    /**
+     * Destroies this plugin.
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,6 @@
+export * from "./BaseSection";
+export * from "./AxisPlaneSection";
+export * from "./ObjectsBoxSection";
+export * from "./PickPlaneSection";
+export * from "./SectionPlugin";
+export * from "./Section.constants";

package/dist/types/settings-3d/Locale.d.ts

@@ -0,0 +1,61 @@
+import { i18n } from "@gcode-viewer/core";
+export declare const en: {
+    settings: string;
+    showOutline: string;
+    doubleSidedMaterials: string;
+    showGroundGrid: string;
+    groundGridHeight: string;
+    showViewCube: string;
+    showAxesHelper: string;
+    enableGroundShadow: string;
+    enableQuantization: string;
+    regenGroundShadowTitle: string;
+    skybox: string;
+    colorWhite: string;
+    colorBlack: string;
+    colorGray: string;
+    gradientColor1: string;
+    gradientColor2: string;
+    gradientColor3: string;
+    setEnvMap: string;
+    default: string;
+    cityStreet: string;
+    grass: string;
+    sunshine: string;
+    showPerformanceStats: string;
+    language: string;
+    languageEn: string;
+    languageZh: string;
+};
+export declare const zh: {
+    settings: string;
+    showOutline: string;
+    doubleSidedMaterials: string;
+    showGroundGrid: string;
+    groundGridHeight: string;
+    showViewCube: string;
+    showAxesHelper: string;
+    enableGroundShadow: string;
+    enableQuantization: string;
+    regenGroundShadowTitle: string;
+    skybox: string;
+    colorWhite: string;
+    colorBlack: string;
+    colorGray: string;
+    gradientColor1: string;
+    gradientColor2: string;
+    gradientColor3: string;
+    setEnvMap: string;
+    default: string;
+    cityStreet: string;
+    grass: string;
+    sunshine: string;
+    showPerformanceStats: string;
+    language: string;
+    languageEn: string;
+    languageZh: string;
+};
+export declare const SETTINGS_3D_I18N_NAMESPACE: "settings3d";
+export { i18n };
+export type Settings3dTranslationKey = keyof typeof en;
+export declare function t(key: Settings3dTranslationKey): string;

package/dist/types/settings-3d/Settings3dPlugin.d.ts

@@ -0,0 +1,46 @@
+import { Viewer3d, Plugin, PluginConfig } from "@gcode-viewer/core";
+import { BasePanel } from "@gcode-viewer/ui";
+/**
+ * Setting 3d plugin.
+ */
+export interface Settings3dPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Container div id.
+     */
+    containerId?: string;
+    /**
+     * If panel is visible. It is visible by default.
+     */
+    visible?: boolean;
+}
+/**
+ * Setting 3d plugin events.
+ */
+type Settings3dPluginEvents = {
+    /**
+     * Panel visibility change event.
+     */
+    visibilitychange: boolean;
+};
+/**
+ * Setting 3d.
+ * Can be used by Viewer3d.
+ */
+export declare class Settings3dPlugin extends Plugin<Settings3dPluginEvents> {
+    static readonly DEFAULT_ID = "Settings3dPlugin";
+    protected cfg: Settings3dPluginConfig;
+    protected basePanel?: BasePanel;
+    protected container?: HTMLDivElement;
+    protected content?: HTMLDivElement;
+    constructor(viewer: Viewer3d, cfg?: Settings3dPluginConfig);
+    protected init(): void;
+    private onLanguageChange;
+    protected applyLocalizedChrome(): void;
+    private applyLanguageSelectChrome;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    destroy(): void;
+    addContent(): void;
+    protected addEventHandlers(): void;
+}
+export {};

package/dist/types/settings-3d/index.d.ts

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

package/dist/types/skybox/GradientColorSkybox.d.ts

@@ -0,0 +1,9 @@
+import { THREE } from "@gcode-viewer/core";
+export declare class GradientColorSkybox extends THREE.Mesh {
+    static readonly NAME = "SKYBOX";
+    static readonly MIN_SKY_RADIUS = 50000;
+    static readonly MAX_SKY_RADIUS = 200000;
+    private vertexShader;
+    private fragmentShader;
+    constructor(topColor: THREE.Color, skylineColor: THREE.Color, bottomColor: THREE.Color, radius?: number, widthSegments?: number, heightSegments?: number, skyCenter?: THREE.Vector3, sunDirection?: THREE.Vector3);
+}

package/dist/types/skybox/SkyboxPlugin.d.ts

@@ -0,0 +1,48 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+import { GradientColorSkybox } from "./GradientColorSkybox";
+/**
+ * Skybox plugin config.
+ */
+export interface SkyboxPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Initial single color of the skybox.
+     * If specified, it initialize with a single color background. Otherwise,
+     * the skybox initialize with default gradient colors.
+     */
+    color?: number[];
+}
+/**
+ * Skybox plugin. It is mainly used by Viewer3d, while can also be used by Viewer2d.
+ * You can set skybox in several means:
+ * 1) Single color, by using setSkyboxByColor().
+ * 2) Gradient colors, by using setSkyboxByGradientColors().
+ * 3) Cube texture, by using setSkyboxByCubeTexture().
+ */
+export declare class SkyboxPlugin extends Plugin {
+    static readonly DEFAULT_ID = "SkyboxPlugin";
+    protected gradientColorSkybox?: GradientColorSkybox;
+    protected enabled: boolean;
+    constructor(viewer: BaseViewer, cfg?: SkyboxPluginConfig);
+    setEnabled(enable: boolean): void;
+    isEnabled(): boolean;
+    /**
+     * Set skybox by a single color.
+     * @param color rgb number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96]
+     */
+    setSkyboxByColor(color?: number[]): void;
+    /**
+     * Sets skybox by 3 gradient colors (top, skyline, bottom).
+     */
+    setSkyboxByGradientColors(topColor?: number[], // 0x86b6f5
+    skylineColor?: number[], // 0xffffff
+    bottomColor?: number[]): void;
+    /**
+     * Sets skybox by cube texture (6 images).
+     */
+    setSkyboxByCubeTexture(urls: string[]): void;
+    destroy(): void;
+    /**
+     * Converts rgb color number array to THREE.Color.
+     */
+    protected rgb2Color(color: number[]): THREE.Color;
+}

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

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

package/dist/types/stats/StatsPlugin.d.ts

@@ -0,0 +1,18 @@
+import { BaseViewer, Plugin } from "@gcode-viewer/core";
+import Stats from "stats.js";
+/**
+ * Stats plugin is a debug tool for developers to observe the performance of a page.
+ */
+export declare class StatsPlugin extends Plugin {
+    static readonly DEFAULT_ID = "StatsPlugin";
+    protected stats?: Stats;
+    /** Mirrors {@link setVisible}: stats.js uses `showPanel(-1)` to hide all panels. */
+    private statsUiVisible;
+    constructor(viewer: BaseViewer);
+    /**
+     * Shows or hide the stats panel, which indicates current FPS, MS, MB, etc.
+     */
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    destroy(): void;
+}

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

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

package/dist/types/step-loader/OcctImportScriptLoader.d.ts

@@ -0,0 +1,22 @@
+export type OcctImportModuleConfig = {
+    locateFile?: (path: string, prefix: string) => string;
+};
+export type OcctImportResult = {
+    success: boolean;
+    reason?: string;
+};
+export type OcctImportRuntime = {
+    ReadStepFile: (content: Uint8Array, params: unknown) => OcctImportResult;
+    ReadIgesFile: (content: Uint8Array, params: unknown) => OcctImportResult;
+    ReadBrepFile: (content: Uint8Array, params: unknown) => OcctImportResult;
+};
+export type OcctImportFactory = (config?: OcctImportModuleConfig) => Promise<OcctImportRuntime>;
+/**
+ * Loads occt-import-js IIFE bundle once per script URL and returns the runtime factory.
+ */
+export declare function loadOcctImportOnce(scriptUrl: string): Promise<OcctImportFactory>;
+export declare function buildOcctModuleConfig(wasmBaseUrl: string): OcctImportModuleConfig;
+/**
+ * Single cached occt-import-js wasm runtime per (scriptUrl, wasmBaseUrl). Shared by STEP, IGES, and BREP loaders.
+ */
+export declare function getOcctImportRuntime(scriptUrl: string, wasmBaseUrl: string): Promise<OcctImportRuntime>;

package/dist/types/step-loader/StepLoaderPlugin.d.ts

@@ -0,0 +1,22 @@
+import { BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+export interface StepLoaderPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Folder URL for `occt-import-js.wasm` (trailing `/` optional), passed to `locateFile`.
+     * Default: jsDelivr `occt-import-js` `dist/`.
+     */
+    wasmBaseUrl?: string;
+    /**
+     * Full URL to `occt-import-js.js`.
+     * Default: jsDelivr `occt-import-js`.
+     */
+    scriptUrl?: string;
+}
+/**
+ * Registers STEP (`.step` / `.stp`), IGES (`.iges` / `.igs`), and BREP (`.brep` / `.rle`) via one occt-import-js loader.
+ */
+export declare class StepLoaderPlugin extends Plugin {
+    static readonly DEFAULT_ID = "StepLoaderPlugin";
+    private readonly loader;
+    constructor(viewer: BaseViewer, cfg?: StepLoaderPluginConfig);
+    destroy(): void;
+}