@x-viewer/core 0.9.0

package/dist/types/Locale.d.ts

@@ -0,0 +1,23 @@
+export declare const en: {
+    ProgressBar: {
+        Loading: string;
+        LoadingFailed: string;
+        Comparing: string;
+    };
+    Tooltip: {
+        boxSelect: string;
+        pickMarkup: string;
+    };
+};
+export declare const cn: {
+    ProgressBar: {
+        Loading: string;
+        LoadingFailed: string;
+        Comparing: string;
+    };
+    Tooltip: {
+        boxSelect: string;
+        pickMarkup: string;
+    };
+};
+export declare const i18n: import("i18next").i18n;

package/dist/types/components/dxf-layout-bar/DxfLayoutBar.d.ts

@@ -0,0 +1,26 @@
+import type { Viewer2d } from "../../core/viewers";
+export declare class DxfLayoutBar {
+    protected readonly viewer: Viewer2d;
+    private element?;
+    private content?;
+    private itemList;
+    constructor(viewer: Viewer2d);
+    init(): void;
+    private handleMouseWheel;
+    private createItem;
+    destroy(): void;
+    show(): void;
+    hide(): void;
+}
+export declare class ModelLayoutSwitchItem {
+    protected readonly viewer: Viewer2d;
+    private eventBus;
+    element: HTMLElement;
+    resetActivate?: () => void;
+    active: boolean;
+    constructor(viewer: Viewer2d, name: string);
+    private createItem;
+    setActive(active: boolean): void;
+    resetActive(): void;
+    destroy(): void;
+}

package/dist/types/components/dxf-layout-bar/index.d.ts

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

package/dist/types/components/tool-tip/Tooltip.d.ts

@@ -0,0 +1,20 @@
+interface TooltipConfig {
+    showOnCreate?: boolean;
+    followPointer?: boolean;
+    parentNode?: HTMLElement;
+    target?: HTMLElement;
+}
+export declare class Tooltip {
+    private node;
+    private parentNode;
+    private target;
+    private childNode;
+    constructor(id: string, content?: string | HTMLElement | null, cfg?: TooltipConfig);
+    setContent(content: string | HTMLElement): void;
+    updateChildContent(content: string | HTMLElement): void;
+    follow: (event: MouseEvent) => void;
+    show: () => false | void;
+    hide: () => false | void;
+    destroy: () => void;
+}
+export {};

package/dist/types/components/tool-tip/index.d.ts

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

package/dist/types/core/Configs.d.ts

@@ -0,0 +1,288 @@
+import * as THREE from "three";
+/**
+ * Camera projection type.
+ */
+export declare enum CameraProjection {
+    Perspective = "Perspective",
+    Orthographic = "Orthographic"
+}
+/**
+ * Camera info
+ */
+export interface CameraInfo {
+    /**
+     * Camera projection type
+     */
+    projection: CameraProjection;
+    /**
+     * The camera position
+     */
+    position: THREE.Vector3;
+    /**
+     * The target that the camera looks to
+     */
+    target: THREE.Vector3;
+    /**
+     * @internal
+     */
+    up?: THREE.Vector3;
+    /**
+     * The camera zoom
+     */
+    zoom?: number;
+    /**
+     * The camera's near clip plane
+     */
+    near?: number;
+    /**
+     * The camera's far clip plane
+     */
+    far?: number;
+    /**
+     * Used by perspective camera
+     */
+    fov?: number;
+    /**
+     * Used by perspective camera
+     */
+    aspect?: number;
+    /**
+     * Used by orthographic camera
+     */
+    left?: number;
+    /**
+     * Used by orthographic camera
+     */
+    right?: number;
+    /**
+     * Used by orthographic camera
+     */
+    bottom?: number;
+    /**
+     * Used by orthographic camera
+     */
+    top?: number;
+}
+/**
+ * Model config
+ */
+export interface ModelConfig {
+    /**
+     * Unique id of the model
+     */
+    modelId?: string;
+    /**
+     * Model name
+     */
+    name?: string;
+    /**
+     * Source url of the model
+     */
+    src: string;
+    /**
+     * Used to distinguish format, because it may be hard to know the format by src!
+     * @internal
+     */
+    fileFormat?: string;
+    /**
+     * File encoding, can be used by dxf. Common encoding include "UTF-8", "gb2312", etc.
+     * @internal
+     */
+    encoding?: string;
+    /**
+     * A float array of length 16, definds model's position, rotation and scale
+     */
+    matrix?: number[];
+    /**
+     * If we want to merge meshes/lines/points with the same material
+     * @internal
+     * @default false
+     */
+    merge?: boolean;
+    /**
+     * If we want to generate and show edges/outlines to the modle.
+     * It is useful for Viewer3d.
+     * @internal
+     */
+    edges?: boolean;
+    /**
+     * If this model is visible by default.
+     * @internal
+     */
+    visible?: boolean;
+    /**
+     * This is only useful for obj model, mtl is material file.
+     * @internal
+     */
+    mtlUrls?: string[];
+}
+/**
+ * 2d model config
+ */
+export interface Model2dConfig extends ModelConfig {
+    /**
+     * If to ignore anything of paper space.
+     * There are some scenarios to ignore paper space by default, includes:
+     * - Dxf overlay, aka, loading more than one dxf files into a viewer. We'll only load model space for the first file.
+     * - Dxf compare. Since we'll only compare model space, it won't load paper space at all.
+     *
+     * This option is useful when user want to explicitly ignore paper space.
+     * @default false
+     */
+    ignorePaperSpace?: boolean;
+    /**
+     * Applies this color to everything in this model.
+     * This allows user to show a drawing with a pure color (black, white, etc.).
+     * Color value is between 0 and 1, e.g., [1, 0, 0] means 'red'.
+     */
+    overrideColor?: number[];
+}
+/**
+ * Common viewer config
+ */
+export interface BaseViewerConfig {
+    /**
+     * @description canvas id to contain the viewer.
+     */
+    containerId: string;
+    /**
+     * Language of the viewer.
+     * @description Default is `en`.
+     */
+    language?: "cn" | "en";
+    /**
+     * @internal
+     */
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * @internal
+     */
+    enableSpinner?: boolean;
+    /**
+     * @internal
+     */
+    enableProgressBar?: boolean;
+    /**
+     * @description just for react native
+     * @internal
+     */
+    context?: WebGLRenderingContext | WebGL2RenderingContext;
+    /**
+     * @description just for react native
+     * @internal
+     */
+    context2d?: CanvasRenderingContext2D;
+}
+/**
+ * This wrappers most config for Viewer3d
+ */
+export interface Viewer3dConfig extends BaseViewerConfig {
+    /**
+     * Default is `meters`
+     * @internal
+     */
+    units?: string;
+}
+/**
+ * This wrappers most config for Viewer2d
+ */
+export interface Viewer2dConfig extends BaseViewerConfig {
+    /**
+     * Enables layout bar so we can switch to other layouts.
+     * The default layout bar is an example UI of the viewer, since plenty of APIs are exposed,
+     * you are recommended to create your own layout bar with customized style, location, etc.
+     */
+    enableLayoutBar?: boolean;
+    /**
+     * If to cache model into indexeddb (or maybe local storage in future).
+     * If enabled, it will get model data from cache the next time model is loaded.
+     * @internal
+     * @default true
+     */
+    enableLocalCache?: boolean;
+}
+/**
+ * Dxf compare config.
+ */
+export interface DxfCompareConfig {
+    /**
+     * Enables to compare properties (color, linetype, line width, etc.)
+     */
+    enableDetailComparision: boolean;
+}
+/**
+ * A default Viewer3dConfig as a template, which enables most plugins.
+ * @internal
+ */
+export declare const DefaultViewer3dConfig: Viewer3dConfig;
+/**
+ * @internal
+ */
+export interface IsolateObjectsParam {
+    id: string;
+    modelId: string;
+}
+/**
+ * @internal
+ */
+export interface IsolateObjectsParams {
+    familyInstanceIds: IsolateObjectsParam[];
+}
+/**
+ * @internal
+ */
+export interface ScreenshotConfig {
+    type: string;
+    quality: number;
+    includeOverlay: boolean;
+}
+/**
+ * Viewpoint definition.
+ */
+export interface Viewpoint {
+    /**
+     * The camera location
+     */
+    eye: THREE.Vector3;
+    /**
+     * The location that the camera looks to
+     */
+    look: THREE.Vector3;
+    /**
+     * @internal
+     */
+    up?: THREE.Vector3;
+    /**
+     * The camera zoom, used by Orthographic camera.
+     */
+    zoom?: number;
+}
+/**
+ * View direction.
+ */
+export declare enum ViewDirection {
+    Top = "Top",
+    Bottom = "Bottom",
+    Front = "Front",
+    Back = "Back",
+    Left = "Left",
+    Right = "Right"
+}
+/**
+ * Icon class.
+ * Used by toolbar and bottom bar icons, etc.
+ */
+export interface IconClass {
+    /**
+     * The default icon.
+     */
+    default: string;
+    /**
+     * The icon when item is actived.
+     */
+    active?: string;
+    /**
+     * The icon font class name.
+     */
+    iconFont?: string;
+}

package/dist/types/core/Constants.d.ts

@@ -0,0 +1,81 @@
+export declare const DefaultLanguage = "en";
+/**
+ * To improve performance, we can set object.matrixAutoUpdate = false for static or rarely moving objects and
+ * manually call object.updateMatrix() whenever their position/rotation/quaternion/scale are updated.
+ * Add a constrant here, so developer can change it here easily for debugging.
+ * @internal
+ */
+export declare const MatrixAutoUpdate = false;
+/**
+ * These concept can be complex: hitable, snapable, selectable, visible
+ * Mesh                            Y        Y         Y           Y
+ * text in Viewer2d                Y        N         Y           Y
+ * ground plan                     Y        Y         N           Y
+ * outline                         N        Y         N           Y
+ * OSnap auxiliary object          N        Y         N           N
+ *
+ * So, we must handle them properly. We'll try to put them into different layers.
+ *
+ * For each created object with geometry and material, the default layer is set to enableAll.
+ * If the object is only displayed, it is not necessary to call enableAll. For example, some auxiliary display objects.
+ * For objects that cannot be hitable, snapable, selectable, etc., call ObjectUtils.disableLayerChannels to exclude the corresponding channel.
+ * @example
+ * ``` typescript
+ *   this.groundPlane.layers.enableAll();
+ *   ObjectUtils.disableLayerChannels(this.groundPlane, [LayerForSelectableObjects]);
+ * ```
+ */
+/**
+ * @internal
+ */
+export declare const LayerForHitableObjects = 10;
+/**
+ * @internal
+ */
+export declare const LayerForSnapableObjects = 11;
+/**
+ * @internal
+ */
+export declare const LayerForSelectableObjects = 12;
+/**
+ * Object highlight color.
+ */
+export declare const HighlightColor = 583902;
+/**
+ * Object highlight color in rgba format.
+ */
+export declare const HighlightColorRgba: number[];
+/**
+ * Object outline color.
+ */
+export declare const OutlineColorRgba: number[];
+/**
+ * Default object opacity value.
+ */
+export declare const DefaultOpacity = 0.5;
+/**
+ * Default camera settings.
+ */
+export declare const DefaultCameraNear = 1;
+export declare const DefaultCameraFar = 5000;
+export declare const DefaultCameraFov = 45;
+/**
+ * Iconfont class name for toolbar, bottombar, section, etc..
+ * This sdk should not provide any UI (toolbar, layoutbar, etc.), thus, it doesn't
+ * need to provide any icon either.
+ * For internal usage, we implemented some icons using iconfont. They are:
+ * - public/iconfont/iconfont.css
+ * - public/iconfont/iconfont2.css
+ * They sould be loaded by user's app, rather than in this sdk.
+ * @internal
+ */
+export declare const IconfontClass = "x-viewer-iconfont";
+/**
+ * @internal
+ */
+export declare const IconfontClass2 = "x-viewer-iconfont2";
+/**
+ * @internal
+ * Angle threshold at which two plane normals are parallel. Used to calculate edges.
+ */
+export declare const ThresholdAngleForEdge = 10;

package/dist/types/core/Units.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Units are defined the same order as to Dxf format
+ */
+export declare enum Units {
+    Unitless = "Unitless",
+    Inches = "Inches",
+    Feet = "Feet",
+    Millimeters = "Millimeters",
+    Centimeters = "Centimeters",
+    Meters = "Meters"
+}
+/**
+ * Gets the unit scale when converting to meter.
+ */
+export declare const UnitScaleToMeter: (src: Units) => number;
+export declare const UnitScaleConversion: (src: Units, dest: Units) => number;

package/dist/types/core/VersionManager.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gets the sdk version ran on this device from local storage.
+ */
+export declare const getVersionFromLocalStorage: () => string | null;
+/**
+ * Sets the sdk version to local storage.
+ */
+export declare const setVersionToLocalStorage: () => void;
+/**
+ * Checks if current sdk version and last version are different.
+ * There can be storage data formant change if sdk version is updated,
+ * we may simply clean up local storage in this case.
+ */
+export declare const checkIsNewVersion: () => boolean;

package/dist/types/core/camera/CameraManager.d.ts

@@ -0,0 +1,80 @@
+import * as THREE from "three";
+import { CameraInfo, CameraProjection, Viewpoint } from "../../core/Configs";
+import CameraControls from "../../core/camera-controls";
+import { FitToOptions } from "../../core/camera-controls/types";
+import { ControlsMode } from "../../core/controls/Control";
+import { type BaseViewer } from "../../core/viewers/BaseViewer";
+export declare class CameraManager {
+    private viewer;
+    readonly perspectiveCamera: THREE.PerspectiveCamera;
+    readonly orthographicCamera: THREE.OrthographicCamera;
+    activeCamera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    readonly cameraControls: CameraControls;
+    private previousDistance;
+    private previousAzimuthRotateSpeed;
+    private previousPolarRotateSpeed;
+    private previousDollySpeed;
+    private previousTruckSpeed;
+    private previousMouseLeft;
+    protected enableKeyDown: boolean;
+    /**
+     * A map/list of different controls
+     */
+    private controlsMap;
+    private activeControls;
+    private projection;
+    /**
+     * For OrbitControls, a user would like to rotate around where mouse is clicked,
+     * rather than the screen center.
+     * We'll display an anchor at where mouse is clicked.
+     */
+    protected anchor: HTMLElement;
+    constructor(viewer: BaseViewer);
+    get viewerContainer(): HTMLElement;
+    get inputManager(): import("../../core/input-manager/InputManager").InputManager;
+    private createAnchor;
+    protected setAnchorPosition(x: number, y: number): void;
+    setOrbitPointVisible(visible: boolean): void;
+    isOrbitPointVisible(): boolean;
+    private setOrthoCameraAspect;
+    private setupCameras;
+    private setCameraPositionAndTarget;
+    private setupControls;
+    private onKeyDown;
+    private onChange;
+    setOrthoCamera(): void;
+    private getDims;
+    private setupOrthoCamera;
+    private setPerspectiveCamera;
+    update(delta: number): boolean;
+    updateAspect(): void;
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    enableKeyControl(enable: boolean): void;
+    getTarget(): THREE.Vector3;
+    getPosition(): THREE.Vector3;
+    adjustCameraByBBox(bbox: THREE.Box3): void;
+    enableControl(active: boolean): void;
+    get enableRotate(): boolean;
+    set enableRotate(enable: boolean);
+    enableZoom(enable: boolean): void;
+    enablePan(enable: boolean): void;
+    enableMouseLeft(enable: boolean): void;
+    setCameraPosition(position: THREE.Vector3): void;
+    setCameraTarget(target: THREE.Vector3): void;
+    flyTo(position: THREE.Vector3, lookAt: THREE.Vector3, enableTransition?: boolean): void;
+    flyToPosition(x: number, y: number, z: number): void;
+    flyToBox(box: THREE.Box3, fitOptions?: Partial<FitToOptions>): void;
+    fitToSphere(box: THREE.Object3D | THREE.Sphere): void;
+    flyToObject(object: THREE.Object3D): void;
+    flyToViewpoint(viewpoint: Viewpoint): void;
+    getDistanceToFitSphere(radius: number): number;
+    setNavigationMode(mode: ControlsMode): void;
+    getProjection(): CameraProjection;
+    setProjection(proj: CameraProjection): void;
+    setOrbitPoint(point: THREE.Vector3): void;
+    getCameraDirection(): THREE.Vector3;
+    getCameraInfo(): CameraInfo;
+    getCurrentViewpoint(): Viewpoint;
+    goToViewpoint(vp: Viewpoint): void;
+    destroy(): void;
+}

package/dist/types/core/camera/index.d.ts

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