@inweb/client 25.2.2

package/lib/Viewer/Markup/Impl/Konva/MarkupColor.d.ts

@@ -0,0 +1,19 @@
+export declare class MarkupColor {
+    R: number;
+    G: number;
+    B: number;
+    private _hex;
+    /**
+     * Color in #000000 format
+     */
+    get HexColor(): string;
+    get RGB(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    constructor(r: number, g: number, b: number);
+    setColor(r: number, g: number, b: number): void;
+    private rgbToHex;
+}
+//# sourceMappingURL=MarkupColor.d.ts.map

package/lib/Viewer/Markup/Impl/Visualize/VisualizeMarkup.d.ts

@@ -0,0 +1,33 @@
+import { IMarkup } from "../../IMarkup";
+import { Viewer } from "../../../Viewer";
+import { OdBaseDragger } from "../../../Draggers/Common/OdBaseDragger";
+import { IMarkupObject } from "../../Api/IMarkupObject";
+export declare class VisualizeMarkup implements IMarkup {
+    private _viewer;
+    protected _markupColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lineWidth: number;
+    initialize(viewer: Viewer, canvas: HTMLCanvasElement, canvasEvents: string[]): void;
+    dispose(): void;
+    getDraggers(): Map<string, typeof OdBaseDragger>;
+    clearOverlay(): void;
+    getMarkupColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    setMarkupColor(r: number, g: number, b: number): void;
+    colorizeAllMarkup(r?: number, g?: number, b?: number): void;
+    drawViewpoint(viewpoint: any): void;
+    createViewpoint(): object;
+    getLayer(): any;
+    createObject(type: string, params: any): IMarkupObject;
+    getObjects(): IMarkupObject[];
+    getSelectedObjects(): IMarkupObject[];
+    selectObjects(objects: IMarkupObject[]): void;
+    clearSelected(): void;
+}
+//# sourceMappingURL=VisualizeMarkup.d.ts.map

package/lib/Viewer/Markup/MarkupFactory.d.ts

@@ -0,0 +1,7 @@
+import { IMarkup, MarkupType } from "./IMarkup";
+export declare class MarkupFactory {
+    static createMarkup(markupType: MarkupType): IMarkup;
+    private static createKonva;
+    private static createVisualize;
+}
+//# sourceMappingURL=MarkupFactory.d.ts.map

package/lib/Viewer/Options.d.ts

@@ -0,0 +1,228 @@
+import { EventEmitter2 } from "./EventEmitter2";
+export interface RGB {
+    red: number;
+    green: number;
+    blue: number;
+}
+/**
+ * `VisualizeJS` parameters.
+ */
+export interface OptionsData {
+    /**
+     * Show WCS
+     *
+     * @defaultValue true
+     */
+    showWCS?: boolean;
+    /**
+     * Enable camera animation
+     *
+     * @defaultValue true
+     */
+    cameraAnimation?: boolean;
+    /**
+     * Enable antialiasing use FXAA
+     *
+     * @defaultValue true
+     */
+    antialiasing?: boolean;
+    /**
+     * Enable ground shadows
+     *
+     * @defaultValue false
+     */
+    groundShadow?: boolean;
+    /**
+     * Enable shadows
+     *
+     * @defaultValue false
+     */
+    shadows?: boolean;
+    /**
+     * Camera speed on X axis
+     *
+     * @defaultValue 4
+     */
+    cameraAxisXSpeed?: number;
+    /**
+     * Camera speed on Y axis
+     *
+     * @defaultValue 1
+     */
+    cameraAxisYSpeed?: number;
+    /**
+     * Ambient occlusion
+     *
+     * @defaultValue false
+     */
+    ambientOcclusion?: boolean;
+    /**
+     * Enable partial load mode to be able open large drawing If enablePartialMode enabled, then
+     * sceneGraph will be switched off
+     *
+     * @defaultValue false
+     */
+    enablePartialMode?: boolean;
+    /**
+     * The size of the memory buffer that the Viewer can use for graphics data
+     *
+     * @defaultValue 3294967296
+     */
+    memoryLimit?: number;
+    /**
+     * Cutting plane fill color
+     *
+     * @defaultValue { red: 0xff, green: 0x98, blue: 0x00 }
+     */
+    cuttingPlaneFillColor?: RGB;
+    /**
+     * Outline edges color in RGB format.
+     */
+    edgesColor?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    /**
+     * Faces color in the RGB format.
+     */
+    facesColor?: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    /**
+     * Show or hide edges.
+     */
+    edgesVisibility?: boolean;
+    /**
+     * Show edges over drawing.
+     */
+    edgesOverlap?: boolean;
+    /**
+     * Show faces over drawing.
+     */
+    facesOverlap?: boolean;
+    /**
+     * Faces transparency value from 0 to 255.
+     */
+    facesTransparancy?: number;
+    /**
+     * Enable custom highlight settings.
+     */
+    enableCustomHighlight?: boolean;
+    /**
+     * Enable or disable scene graph, it increases perfomance improvement, but consumes memory
+     * Large drawings can take up a lot of memory. If sceneGraph enabled, then enablePartialMode
+     * will be switched off
+     */
+    sceneGraph: boolean;
+    /**
+     * Edge display models. No edges is usefull for less memory consumption: `false` - no edges
+     * are displayed, `true` - display isolines.
+     */
+    edgeModel: boolean;
+    /**
+     * Reverse the mouse wheel direction for zooming: false - moving the wheel up zooms in,
+     * moving down zooms out, `true` - moving the wheel up zooms out, moving down zooms in.
+     */
+    reverseZoomWheel: boolean;
+    /**
+     * Enable mouse wheel zooming.
+     */
+    enableZoomWheel: boolean;
+    /**
+     * Enable touch gestures. This option will be ignored when enableZoomWheel is disabled, since
+     * gestures contains touch zoom.
+     */
+    enableGestures: boolean;
+    /**
+     * Default file geometry data type. Can be one of:
+     *
+     * - `vsfx` - `VSFX` (default), for opening a file in `VisualizeJS` viewer.
+     * - `gltf` - `glTF`, for opening a file in `Three.js` viewer.
+     */
+    geometryType?: string;
+}
+export declare class Options {
+    protected _emitter?: EventEmitter2;
+    protected _data: OptionsData;
+    constructor(emitter?: EventEmitter2);
+    static defaults(): OptionsData;
+    notifierChangeEvent(): void;
+    saveToStorage(): void;
+    loadFromStorage(): void;
+    /**
+     * Reset options to default
+     *
+     * @param fields - Name of fields to be reset
+     */
+    resetToDefaults(fields?: string[]): void;
+    get data(): OptionsData;
+    set data(value: OptionsData);
+    get showWCS(): boolean;
+    set showWCS(value: boolean);
+    get cameraAnimation(): boolean;
+    set cameraAnimation(value: boolean);
+    get antialiasing(): boolean;
+    set antialiasing(value: boolean);
+    get groundShadow(): boolean;
+    set groundShadow(value: boolean);
+    get shadows(): boolean;
+    set shadows(value: boolean);
+    get cameraAxisXSpeed(): number;
+    set cameraAxisXSpeed(value: number);
+    get cameraAxisYSpeed(): number;
+    set cameraAxisYSpeed(value: number);
+    get ambientOcclusion(): boolean;
+    set ambientOcclusion(value: boolean);
+    get enablePartialMode(): boolean;
+    set enablePartialMode(value: boolean);
+    get memoryLimit(): number;
+    set memoryLimit(value: number);
+    get cuttingPlaneFillColor(): RGB;
+    set cuttingPlaneFillColor(value: RGB);
+    get edgesColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    set edgesColor(value: {
+        r: number;
+        g: number;
+        b: number;
+    });
+    get facesColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    set facesColor(value: {
+        r: number;
+        g: number;
+        b: number;
+    });
+    get edgesVisibility(): boolean;
+    set edgesVisibility(value: boolean);
+    get edgesOverlap(): boolean;
+    set edgesOverlap(value: boolean);
+    get facesOverlap(): boolean;
+    set facesOverlap(value: boolean);
+    get facesTransparancy(): number;
+    set facesTransparancy(value: number);
+    get enableCustomHighlight(): boolean;
+    set enableCustomHighlight(value: boolean);
+    get sceneGraph(): boolean;
+    set sceneGraph(value: boolean);
+    get edgeModel(): boolean;
+    set edgeModel(value: boolean);
+    get reverseZoomWheel(): boolean;
+    set reverseZoomWheel(value: boolean);
+    get enableZoomWheel(): boolean;
+    set enableZoomWheel(value: boolean);
+    get enableGestures(): boolean;
+    set enableGestures(value: boolean);
+    get geometryType(): string;
+    set geometryType(value: string);
+}
+//# sourceMappingURL=Options.d.ts.map

package/lib/Viewer/OptionsEvents.d.ts

@@ -0,0 +1,26 @@
+import { Options } from "./Options";
+/**
+ * An event that fires when options has been changed.
+ *
+ * @event
+ */
+export interface OptionsChangeEvent {
+    /**
+     * Event type.
+     */
+    type: "optionschange";
+    /**
+     * New parameters.
+     */
+    data: Options;
+}
+/**
+ * Options events.
+ */
+export interface OptionsEventMap {
+    /**
+     * An event that fires when options has been changed.
+     */
+    optionschange: OptionsChangeEvent;
+}
+//# sourceMappingURL=OptionsEvents.d.ts.map

package/lib/Viewer/Viewer.d.ts

@@ -0,0 +1,353 @@
+import { IViewer } from "./IViewer";
+import { EventEmitter2 } from "./EventEmitter2";
+import { ViewerEventMap } from "./ViewerEvents";
+import { OptionsEventMap } from "./OptionsEvents";
+import { OdBaseDragger } from "./Draggers/Common/OdBaseDragger";
+import { Client } from "../Api/Client";
+import { File } from "../Api/File";
+import { Assembly } from "../Api/Assembly";
+import { Model } from "../Api/Model";
+import { Options, OptionsData } from "./Options";
+import { IMarkup, MarkupType } from "./Markup/IMarkup";
+/**
+ * The `Client.js` library class that provides methods to integrate with the
+ * [VisualizeJS](https://cloud.opendesign.com/docs/index.html#/visualizejs) library.
+ */
+export declare class Viewer extends EventEmitter2<ViewerEventMap & OptionsEventMap> implements IViewer {
+    private _activeDragger;
+    private _zoomWheelDragger;
+    private _gestureManager;
+    private _enableAutoUpdate;
+    private _isNeedRender;
+    private _isRunAsyncUpdate;
+    private _renderTime;
+    protected _options: Options;
+    protected _visualizeJsUrl: string;
+    protected _abortControllerForReferences: AbortController | undefined;
+    private clientoptionschange;
+    private canvaseventlistener;
+    draggerFactory: Map<string, typeof OdBaseDragger>;
+    canvasEvents: string[];
+    private frameId;
+    private _resizeObserver;
+    canvas: HTMLCanvasElement | undefined;
+    markup: IMarkup;
+    visualizeJs: any;
+    _abortController: AbortController | undefined;
+    _abortControllerForRequestMap: Map<string, AbortController> | undefined;
+    client: Client;
+    /**
+     * @param client - The `Client` instance that provides access to a server. Do not specify
+     *   `Client` if you need a standalone viewer instance without access to server models.
+     * @param params - An object containing viewer configuration parameters.
+     * @param params.visualizeJsUrl - `VisualizeJS` library URL. Set this URL to use your own
+     *   library instance, or leave it undefined or blank to use the default URL defined by
+     *   `Client.js` you are using.
+     *
+     *   _Note: Your own `VisualizeJS` library version must match the version of the `Client.js`
+     *   you are using._
+     * @param params.enableAutoUpdate - Enable auto-update of the viewer after any changes. If
+     *   the auto-update is disabled, you need to update the `VisualizeJS` viewer and the active
+     *   dragger manually using the `update` event. Default is `true`.
+     */
+    constructor(client?: Client, params?: {
+        visualizeJsUrl?: string;
+        enableAutoUpdate?: boolean;
+        markupType?: MarkupType;
+    });
+    /**
+     * `VisualizeJS` parameters.
+     *
+     * Use this only for standalone viewer instances. Use {@link Client#options | Client.options}
+     * instead if the viewer was created with a `Client` reference using
+     * {@link Viewer | Viewer.create(client)}. Changes in client options will be automatically
+     * applied to the viewer options.
+     */
+    get options(): Options;
+    /**
+     * `VisualizeJS` library URL. Use {@link Viewer#configure | configure()} to change library URL.
+     *
+     * @readonly
+     */
+    get visualizeJsUrl(): string;
+    /**
+     * Change the viewer configuration parameters.
+     *
+     * @param params - An object containing new configuration parameters.
+     * @param params.visualizeJsUrl - `VisualizeJS` library URL. Set this URL to use your own
+     *   library instance or leave it blank to use the default URL defined by `Client.js`.
+     */
+    configure(params: {
+        visualizeJsUrl?: string;
+    }): this;
+    /**
+     * A [Viewer]{@link Viewer} event measuring progress of loading a `VisualizeJS` library.
+     *
+     * @property {string} type - `visualizeprogress`
+     * @property {number} loaded - A 64-bit unsigned integer value indicating the amount of work
+     *   already performed by the underlying process. The ratio of work done can be calculated by
+     *   dividing total by the value of this property.
+     * @property {number} total - A 64-bit unsigned integer representing the total amount of work
+     *   that the underlying process is in the progress of performing.
+     * @event visualizeprogress
+     */
+    /**
+     * Load `VisualizeJS` module and initialize it with the specified canvas. Call
+     * {@link Viewer#dispose | dispose()} to release allocated resources.
+     *
+     * @async
+     * @param canvas - HTML `<canvas>` element for `VisualizeJS`.
+     * @param onProgress - A callback function that handles events measuring progress of loading
+     *   of the `VisualizeJS` library. Retrieves {@link event:visualizeprogress | visualizeprogress} event.
+     */
+    initialize(canvas: HTMLCanvasElement, onProgress?: (event: ProgressEvent) => void): Promise<this>;
+    /**
+     * Releases all resources allocated by this `Viewer` instance. Call this method before
+     * release the `Viewer` instance.
+     */
+    dispose(): this;
+    /**
+     * Returns `true` if `VisualizeJS` module has been loaded andinitialized.
+     */
+    isInitialized(): boolean;
+    private render;
+    resize(): this;
+    /**
+     * Updates the viewer. Do nothing if the auto-update mode is disabled in the constructor (use
+     * the `update` event to update viewer manually).
+     *
+     * Fires:
+     *
+     * - {@link UpdateEvent | update}
+     *
+     * @param force - If `true` updates the viewer immidietly. Otherwise updates on next
+     *   animation frame. Default is `false`.
+     */
+    update(force?: boolean): void;
+    /**
+     * Update with internal schedule, need after change operation when have long update for
+     * update without lock UI
+     *
+     * @param maxScheduleUpdateTimeInMs - Maximum time for one update, by default 30 ms
+     * @param maxScheduleUpdateCount - Maximum count of schedule update
+     * @returns return void Promise
+     */
+    private scheduleUpdateAsync;
+    updateAsync(maxScheduleUpdateTimeInMs?: number, maxScheduleUpdateCount?: number): Promise<void>;
+    /**
+     * Returns `VisualizeJS`
+     * {@link https://cloud.opendesign.com/docs/index.html#/visualizejs_api | module} instance.
+     */
+    visLib(): any;
+    /**
+     * Returns `VisualizeJS`
+     * {@link https://cloud.opendesign.com/docs/index.html#/vis/Viewer | Viewer} instance.
+     */
+    visViewer(): any;
+    syncOpenCloudVisualStyle(isInitializing: boolean): this;
+    syncOptions(options?: OptionsData): this;
+    syncHighlightingOptions(options?: OptionsData): this;
+    /**
+     * List of names of available draggers:
+     *
+     * - `Line`
+     * - `Text`
+     * - `Pan`
+     * - `Orbit`
+     * - `Zoom`
+     * - `ZoomWindow`
+     * - `OrbitAroundBuilding`
+     * - `MeasureLine`
+     * - `CuttingPlaneXAxis`
+     * - `CuttingPlaneYAxis`
+     * - `CuttingPlaneZAxis`
+     * - `Walk`
+     *
+     * @readonly
+     */
+    get draggers(): string[];
+    /**
+     * Register dragger on draggerFactory.
+     *
+     * @param name - Dragger name.
+     * @param dragger - Dragger class.
+     */
+    registerDragger(name: string, dragger: typeof OdBaseDragger): void;
+    /**
+     * Returns active dragger instance or `null` if there is no active dragger.
+     */
+    activeDragger(): any | null;
+    /**
+     * Set active dragger. `Viewer` must be {@link Viewer#initialize | initialized} before enable
+     * dragger or exception is thrown.
+     *
+     * Fires:
+     *
+     * - {@link ChangeActiveDragger | changeactivedragger}
+     *
+     * @param name - Dragger name. Can be one of the {@link Viewer#draggers | draggers} list.
+     * @returns Returns active dragger instance or `null` if there is no dragger with the given name.
+     */
+    setActiveDragger(name: string): OdBaseDragger | null;
+    /**
+     * Reset the state of the active dragger.
+     */
+    resetActiveDragger(): void;
+    /**
+     * Remove all cutting planes.
+     */
+    clearSlices(): void;
+    /**
+     * Remove markup overlay.
+     */
+    clearOverlay(): void;
+    /**
+     * Synchronize markup overlay.
+     */
+    syncOverlay(): any;
+    /**
+     * Returns `true` if current drawing is 3D drawing.
+     */
+    is3D(): boolean;
+    /**
+     * Returns a list of original handles for the selected entities.
+     */
+    getSelected(): string[];
+    /**
+     * Select model entities by original handles that are obtained using
+     * {@link File.getProperties | File.getProperties()} or
+     * {@link File.searchProperties | File.searchProperties()} methods.
+     *
+     * Fires:
+     *
+     * - {@link SelectEvent | select}
+     *
+     * @param handles - The list of original handles.
+     */
+    setSelected(handles?: string[]): void;
+    /**
+     * Load model references into the viewer. References are images, fonts, or any other files to
+     * correct rendering of the model.
+     *
+     * @async
+     * @param model - Instance of model with references. If a `File` instance is specified
+     *   instead of a model, the file references will be loaded.
+     */
+    loadReferences(model: Model | File | Assembly): Promise<this>;
+    applyModelTransformMatrix(model: Model | Assembly): void;
+    applySceneGraphSettings(options?: Options): void;
+    /**
+     * Loads a model of a file or assembly into the viewer.
+     *
+     * This method requires a [Client]{@link Client | Client} instance to work. For standalone
+     * viewer instance use {@link Viewer#openVsfFile | openVsfFile()} or
+     * {@link Viewer#openVsfxFile | openVsfxFile()}.
+     *
+     * Fires:
+     *
+     * - {@link OpenEvent | open}
+     * - {@link GeometryStartEvent | geometrystart}
+     * - {@link GeometryProgressEvent | geometryprogress}
+     * - {@link DatabaseChunkEvent | databasechunk}
+     * - {@link GeometryChunkEvent | geometrychunk}
+     * - {@link GeometryEndEvent | geometryend}
+     * - {@link GeometryErrorEvent | geometryerror}
+     *
+     * @async
+     * @param model - Model instance to load. If a `File` instance with multiple models is
+     *   specified, the default model will be loaded. If there is no default model, first
+     *   availiable model will be loaded.
+     */
+    open(model: Model | File | Assembly): Promise<this>;
+    /**
+     * Loads a VSF file into the viewer.
+     *
+     * Fires:
+     *
+     * - {@link OpenEvent | open}
+     * - {@link GeometryStartEvent | geometrystart}
+     * - {@link GeometryProgressEvent | geometryprogress}
+     * - {@link DatabaseChunkEvent | databasechunk}
+     * - {@link GeometryEndEvent | geometryend}
+     * - {@link GeometryErrorEvent | geometryerror}
+     *
+     * @param buffer - Binary data buffer to load.
+     */
+    openVsfFile(buffer: Uint8Array | ArrayBuffer): this;
+    /**
+     * Loads a VSFX file into the viewer.
+     *
+     * Fires:
+     *
+     * - {@link OpenEvent | open}
+     * - {@link GeometryStartEvent | geometrystart}
+     * - {@link GeometryProgressEvent | geometryprogress}
+     * - {@link DatabaseChunkEvent | databasechunk}
+     * - {@link GeometryEndEvent | geometryend}
+     * - {@link GeometryErrorEvent | geometryerror}
+     *
+     * @param buffer - Binary data buffer to load.
+     */
+    openVsfxFile(buffer: Uint8Array | ArrayBuffer): this;
+    /**
+     * Cancels asynchronous model loading started by {@link Viewer#open | open()}.
+     */
+    cancel(): this;
+    /**
+     * Unloads the model and clears the viewer.
+     */
+    clear(): this;
+    /**
+     * Get markup color.
+     *
+     * @returns Color with `RGB` values.
+     */
+    getMarkupColor(): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    /**
+     * Set markup color.
+     *
+     * @param r - `Red` part of color.
+     * @param g - `Green` part of color.
+     * @param b - `Blue` part of color.
+     */
+    setMarkupColor(r?: number, g?: number, b?: number): void;
+    /**
+     * Colorize all markup entities with the specified color.
+     *
+     * @param r - `Red` part of color.
+     * @param g - `Green` part of color.
+     * @param b - `Blue` part of color.
+     */
+    colorizeAllMarkup(r?: number, g?: number, b?: number): void;
+    /**
+     * Add an empty markup entity to the overlay.
+     */
+    addMarkupEntity(entityName: string): any;
+    /**
+     * Draw a viewpoint. To get a list of available model viewpoints, use the
+     * {@link Model#getViewpoints | Model.getViewpoints()} or
+     * {@link File#getViewpoints | File.getViewpoints()}.
+     *
+     * @param viewpoint - Viewpoint.
+     */
+    drawViewpoint(viewpoint: any): void;
+    /**
+     * Create a viewpoint. To add a viewpoint to the list of model viewpoints, use the
+     * {@link Model#saveViewpoint | Model.saveViewpoint()} or
+     * {@link File#saveViewpoint | File.saveViewpoint()}.
+     */
+    createViewpoint(): object;
+    /**
+     * Executes the command denoted by the given command identifier.
+     *
+     * @param id - Identifier of the command to execute.
+     * @param args - Parameters passed to the command function.
+     * @returns A returned value of the given command. Returns `undefined` when the command doesn't exists.
+     */
+    executeCommand(id: string, ...args: any[]): any;
+}
+//# sourceMappingURL=Viewer.d.ts.map

package/lib/Viewer/ViewerCommands.d.ts

@@ -0,0 +1,23 @@
+import "./Commands/ApplyModelTransform";
+import "./Commands/ClearMarkup";
+import "./Commands/ClearSlices";
+import "./Commands/CreatePreview";
+import "./Commands/Explode";
+import "./Commands/GetDefaultViewPositions";
+import "./Commands/GetModels";
+import "./Commands/GetSelected";
+import "./Commands/HideSelected";
+import "./Commands/IsolateSelected";
+import "./Commands/RegenerateAll";
+import "./Commands/ResetView";
+import "./Commands/SelectModel";
+import "./Commands/SetActiveDragger";
+import "./Commands/SetDefaultViewPosition";
+import "./Commands/SetMarkupColor";
+import "./Commands/SetSelected";
+import "./Commands/ShowAll";
+import "./Commands/Unselect";
+import "./Commands/ZoomToExtents";
+import "./Commands/ZoomToObjects";
+import "./Commands/ZoomToSelected";
+//# sourceMappingURL=ViewerCommands.d.ts.map