@roomle/web-sdk 2.90.0 → 2.91.0-alpha.2

package/lib/definitions/packages/planner-core/src/webgl/draggable-node.d.ts

@@ -0,0 +1,17 @@
+import { Vector3, Object3D } from 'three';
+export declare const DEFAULT_NODE_SIZE: number;
+export default class DraggableNode extends Object3D {
+    private _sphere;
+    private _innerRingMesh;
+    private _outerRingMesh;
+    private _sphereSize;
+    private _innerRingRadius;
+    private _outerRingRadius;
+    constructor(name: string, sphereSize?: number);
+    private _initNodeMesh;
+    getSize(): Vector3;
+    hoverOn(): void;
+    hoverOff(): void;
+    select(color: number): void;
+    deselect(color: number): void;
+}

package/lib/definitions/packages/planner-core/src/webgl/lightsetting/planner-light-setting.d.ts

@@ -0,0 +1,17 @@
+import LightSetting from '../../../../common-core/src/lightsetting/light-setting';
+import type { Box3, Scene } from 'three';
+export default class PlannerLightSetting extends LightSetting {
+    private _hemiLight;
+    private _ambientLight;
+    private _mainDirLight;
+    private _center;
+    private _params;
+    constructor(scene: Scene, oldLightSetting?: LightSetting);
+    updateSunPosition(_inclination: number, _azimuth: number): void;
+    addToScene(): void;
+    removeFromScene(): void;
+    reload(): void;
+    needsBounds(): boolean;
+    updateBounds(bounds: Box3): void;
+    showGUI(): void;
+}

package/lib/definitions/packages/planner-core/src/webgl/paper-background.d.ts

@@ -0,0 +1,4 @@
+import { Mesh } from 'three';
+export default class PaperBackground extends Mesh {
+    constructor();
+}

package/lib/definitions/packages/planner-core/src/webgl/planner-mesh-generator.d.ts

@@ -0,0 +1,22 @@
+import type { KernelEnum } from '../../../typings/kernel';
+import MeshGenerator from '../../../common-core/src/webgl/mesh-generator';
+import type { BaseMaterial } from '../../../typings/planner-kernel-container';
+import type { BufferGeometry, Mesh } from 'three';
+export declare const enum PLANNER_RENDER_ORDER {
+    WALL = 5
+}
+export default class PlannerMeshGenerator extends MeshGenerator {
+    private _wallMeshes;
+    private _defaultMaterial;
+    private _defaultMaterialFloor;
+    constructor(creator: string);
+    generateGeometry(meshId: string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, newGeometryInstance?: boolean): BufferGeometry;
+    generateMesh(runtimeComponentId: number, geometryId: string, materialId: BaseMaterial | string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, type?: KernelEnum, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    setMaterial(mesh: Mesh, material: BaseMaterial | string, type?: KernelEnum, materialAttributes?: Record<string, string>): Promise<void>;
+    private _getDefaultMaterial;
+    set maxAnisotropy(maxAnisotropy: number);
+    private _checkWallMaterial;
+    clear(): void;
+    clearWallMeshes(): void;
+    get wallMeshes(): Mesh<BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>[];
+}

package/lib/definitions/packages/planner-core/src/webgl/planner-scene-event-handler.d.ts

@@ -0,0 +1,165 @@
+import type InputManager from '../../../common-core/src/input/input-manager';
+import type { InputEvent } from '../../../common-core/src/input/input-manager';
+import type PlanObjectViewModel from '../../../common-core/src/view-model/plan-object-view-model';
+import { SELECTION_MODE } from '../../../configurator-core/src/utils/selection-handler';
+import type PlanViewModel from '../view-model/plan-view-model';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { KernelVector3 } from '../../../typings/kernel';
+import SceneEventHandler from '../../../common-core/src/webgl/scene-event-handler';
+import { type CancelSelectionReasons, type KernelObject, type PlanInteractionHandler } from '../../../typings/planner';
+import type { Camera, Object3D, Scene } from 'three';
+import { Group } from 'three';
+import type { RoomleEventedObject3D } from '../../../common-core/src/utils/threejs-utils';
+import MeasurementLinePlanElementViewModel from '../view-model/measurement-line-plan-element-view-model';
+import type InitData from './../../../common-core/src/utils/init-data';
+export declare const enum PLANNER_SCENE_EVENT {
+    SELECT_PLAN_ELEMENT = 0,
+    DESELECT_PLAN_ELEMENT = 1,
+    STATE_CHANGED = 2,
+    HOVER_ON = 3,
+    HOVER_OFF = 4,
+    DRAW = 5,
+    DRAWING_START = 6,
+    DRAWING_END = 7,
+    BEFORE_DRAG_START = 8,
+    DRAG_START = 9,
+    DRAG_MOVE = 10,
+    DRAG_END = 11,
+    DRAG_CANCEL = 12,
+    INTERACTION = 13,
+    CLICK_OUTSIDE = 14,
+    SELECTION_MODE_CHANGED = 15,
+    ADD_MEASUREMENT_LINE_START = 16,
+    ADD_MEASUREMENT_LINE_END = 17,
+    DRAG_MEASUREMENT_LINE = 18,
+    ACTIVATE_PLAN_ELEMENT = 19
+}
+export declare const enum PLANNER_SCENE_EVENT_STATE {
+    IDLE = 0,
+    DRAG = 1,
+    ROTATE = 2,
+    DRAW = 3,
+    MEASURE = 4
+}
+export declare class SceneEventInfo {
+    planElementViewModel: PlanElementViewModel;
+    resetCamera: boolean;
+    state: PLANNER_SCENE_EVENT_STATE;
+    oldState: PLANNER_SCENE_EVENT_STATE;
+    reason: CancelSelectionReasons;
+    constructor(data: {
+        planElementViewModel?: PlanElementViewModel;
+        resetCamera?: boolean;
+        state?: PLANNER_SCENE_EVENT_STATE;
+        oldState?: PLANNER_SCENE_EVENT_STATE;
+        reason?: CancelSelectionReasons;
+    });
+}
+export interface PlanObjectEventInfo {
+    planElementName: string;
+    hasListener: boolean;
+    priority: number;
+    roomleId: number;
+    snapToWall: boolean;
+}
+export default class PlannerSceneEventHandler extends SceneEventHandler<SceneEventInfo> {
+    private _plannerSelectionHandler;
+    private _plannerKernelAccess;
+    private _roomlePlannerUiCallback;
+    protected _initData: InitData;
+    private _planViewModel;
+    private _draggedObject;
+    private _lastDragPosition;
+    private _hoveredObject;
+    private _position;
+    private _isDrawingEnabled;
+    private _isCurrentlyDrawing;
+    private _isMeasurementLineDrawActive;
+    private _state;
+    private _drawingGroup;
+    private _continuousDrawingHelper;
+    private _kernelZoomFactor;
+    private _currentPlanMeasure;
+    constructor(creator: string, scene: Scene, camera: Camera, inputManager: InputManager);
+    disable(): void;
+    get planInteractionHandler(): PlanInteractionHandler;
+    get hoveredObjectId(): number;
+    get isCurrentlyDrawing(): boolean;
+    enable(): void;
+    enableConstructionEvents(enable: boolean): void;
+    enableObjectEvents(enable: boolean): void;
+    getSelectionMode(): SELECTION_MODE;
+    addConstructionPlanObjectHandlers(planObjectViewModel: PlanObjectViewModel, object?: RoomleEventedObject3D): void;
+    addPlanObjectHandlers(planObjectViewModel: PlanObjectViewModel, object?: RoomleEventedObject3D): void;
+    addWallHandlers(planElementViewModel: PlanElementViewModel): void;
+    addMeasurementLineHandlers(planElementViewModel: MeasurementLinePlanElementViewModel): void;
+    addFloorHandlers(planElementViewModel: PlanElementViewModel): void;
+    addNodeHandlers(planElementViewModel: PlanElementViewModel): void;
+    private _addPlanObjectHandlers;
+    private _addFloorElementHandlers;
+    private _addElementHandlers;
+    private _addPlanElementHandlers;
+    private _addMeasurementLinePlanElementHandlers;
+    private _createFloorMeshWithHandler;
+    private _clickOnPlane;
+    private _doubleClickOnPlane;
+    private _closeToPoint;
+    private _close;
+    private _clickElement;
+    private _doubleClickElement;
+    private _hoverOn;
+    private _hoverOnMultiSelect;
+    private _hoverOnStandard;
+    private _hoverOff;
+    private _isHoveredObjectNonDraggable;
+    private _setCursor;
+    setCamera(camera: Camera): void;
+    setObject(object: Object3D): void;
+    getSelectedIds(): number[];
+    setSelectionMode(selectionMode: SELECTION_MODE): void;
+    setPlanViewModel(planViewModel: PlanViewModel): void;
+    cancelSelection(reason: CancelSelectionReasons): void;
+    removeSelection(): void;
+    private _dragStart;
+    private _drag;
+    private _dragEnd;
+    private _rotate;
+    setState(state: PLANNER_SCENE_EVENT_STATE): void;
+    resetState(): void;
+    private _move;
+    private _hasSelection;
+    selectPlanElement(planElement: PlanElementViewModel): Promise<void>;
+    protected _interaction(_forceRender?: boolean): void;
+    addComponentDragInHandler(planViewModel: PlanElementViewModel): void;
+    enableSnapping(): void;
+    disableSnapping(): void;
+    enableAdvancedDocking(): void;
+    disableAdvancedDocking(): void;
+    showsChildrenOfPlanObject(object: KernelObject): boolean;
+    enableShowChildrenOfPlanObject(object: KernelObject): void;
+    disableShowChildrenOfPlanObject(object: KernelObject): void;
+    private _checkRaycasterSnapping;
+    enableWallDrawing(): Group;
+    cancelWallDrawing(): Group;
+    stopDrawing(cancelDrawing?: boolean): void;
+    startDrawing(): void;
+    private _toggleDrawing;
+    endWallDrawing(event: InputEvent | null, point?: KernelVector3): void;
+    private _startWallDrawing;
+    private _initMobileDrawing;
+    private _drawWallOnMouseMove;
+    private _createNode;
+    private _getIntersectionPointWithScene;
+    private _setStateAndCursor;
+    setKernelZoomFactor(kernelZoomFactor: number): void;
+    enableMeasurementLineDrawing(): void;
+    disableMeasurementLineDrawing(): void;
+    private _handleMeasurementLineDrawingEvent;
+    private _enableDrawingListeners;
+    private _disableDrawingListeners;
+    private _drawMeasurementLineOnMouseMove;
+    private _updateMeasurementLineViewModels;
+    private _createPlanMeasure;
+    private _dragMeasurementLine;
+    setMeasurementLineLength(measurementLine: MeasurementLinePlanElementViewModel, targetLengthMM: number, direction: string): void;
+}

package/lib/definitions/packages/planner-core/src/webgl/planner-scene-manager.d.ts

@@ -0,0 +1,203 @@
+import type { Base64Image, CanvasOffset } from '../../../common-core/src/common-interfaces';
+import type { PlannerKernelCallbackI } from '../services/planner-kernel-access';
+import type { CancelSelectionReasons, Plan, PlanElement } from '../../../typings/planner';
+import { type KernelEnum, type KernelPlanObject, type KernelVector3, type RuntimeId } from '../../../typings/kernel';
+import PlannerSceneEventHandler from './planner-scene-event-handler';
+import type { BatchPaintMaterial, RoomlePlannerCallback, SceneEvents } from '../roomle-planner';
+import type PlanObjectViewModel from '../../../common-core/src/view-model/plan-object-view-model';
+import type InputManager from '../../../common-core/src/input/input-manager';
+import type { SelectionPayload } from '../roomle-planner-ui-callback';
+import { CAMERA_TYPE } from '../../../common-core/src/cameracontrol/camera-type';
+import type PlanElementViewModel from '../../../common-core/src/view-model/plan-element-view-model';
+import type { CameraParameter } from '../../../common-core/src/cameracontrol/camera-control';
+import PlanViewModel from '../view-model/plan-view-model';
+import ConfiguratorSceneManager from '../../../configurator-core/src/webgl/configurator-scene-manager';
+import WallPlanElementViewModel from '../view-model/wall-plan-element-view-model';
+import type UnitFormatter from '../../../configurator-core/src/services/unit-formatter';
+import type { Enumify } from '../../../common-core/src/types';
+import { type Object3D } from 'three';
+import { Box3 } from 'three';
+import type { CameraTarget, PrepareImageOptions } from '../../../common-core/src/webgl/image-renderer';
+import Planner2dCameraBehaviour from '../../../common-core/src/cameracontrol/planner-2d-camera-behaviour';
+import Planner3dCameraBehaviour from '../../../common-core/src/cameracontrol/planner-3d-camera-behaviour';
+import PlannerFpCameraBehaviour from '../../../common-core/src/cameracontrol/planner-fp-camera-behaviour';
+import type { EMSConstant } from '../../../typings/planner-kernel-container';
+declare const SET_WALL_MATERIAL_TYPE: {
+    readonly INTERIOR: "interior";
+    readonly EXTERIOR: "exterior";
+};
+interface PrepareImageOptionsPlanner extends PrepareImageOptions {
+    object?: Object3D;
+}
+export default class PlannerSceneManager extends ConfiguratorSceneManager implements PlannerKernelCallbackI {
+    private _rapiAccess;
+    private _plannerMeshGenerator;
+    private _plannerInputManager;
+    private _roomlePlannerUiCallback;
+    private _localStorageHelper;
+    protected _unitFormatter: UnitFormatter;
+    private _plannerSceneEventHandler;
+    private _roomlePlannerCallback;
+    private _itemsLoadingStatePromises;
+    private _sky;
+    private _drawingEnabled;
+    private _configureInRoom;
+    private _planId;
+    private _preloadScene;
+    private _staticItemGuard;
+    private _completelyLoaded;
+    private _configurableItemGuard;
+    private _planCompletelyLoadedGuard;
+    private _dragStartBounds;
+    currentSelection: SelectionPayload;
+    private _paperBackground;
+    private _debugSpheres;
+    constructor(creator: string, offset: CanvasOffset, plannerCallback: RoomlePlannerCallback, mode: Enumify<typeof CAMERA_TYPE>);
+    get configuratorContext(): import("../../../common-core/src/webgl/configurator-context").default;
+    private _activateElement;
+    planCleared(): void;
+    planHistoryStateChanged(): void;
+    protected _getViewModel(): PlanViewModel;
+    private _getDragPosition;
+    private _hideAllMeasurementsNodeOnElementChange;
+    private _onSelectionChange;
+    private _onSelectionCancel;
+    private _handleMeasurementLineDraggablePoints;
+    resetConfiguratorContext(): void;
+    protected _setupScene(offset?: CanvasOffset, transparent?: boolean): void;
+    protected onBeforeRender(): void;
+    protected _getInputManager(): InputManager;
+    protected createCameraControl(mode: Enumify<typeof CAMERA_TYPE>, _offset: CanvasOffset): void;
+    startViewing(): void;
+    startConfiguring(): void;
+    selectPlanObject(runtimeId: number): Promise<void>;
+    backToPlanner(): void;
+    private _getYRotationOfObject;
+    loadStaticPlanObjects(): void;
+    requestCatalogItem(catalogItemId: string): void;
+    private _staticItemsLoaded;
+    preload(id: string): void;
+    planXMLLoaded(plan: Plan): void;
+    planCompletelyLoaded(_plan: Plan): void;
+    handlerSwitchedPlans(fromPlan: Plan, toPlan: Plan): void;
+    private _itemsLoaded;
+    beginPlanConstruction(_plan: Plan): void;
+    addPlanMesh(_plan: Plan, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array, _type: KernelEnum): void;
+    endPlanConstruction(_plan: Plan): void;
+    addPlanObjectToScene(planViewModel: PlanObjectViewModel): Promise<void>;
+    removePlanObjectFromScene(planViewModel: PlanElementViewModel): void;
+    planElementChanged(_plan: Plan, planElementViewModel: PlanElementViewModel): Promise<void>;
+    exportGLB(_exportObjects?: Object3D[], _id?: string): void;
+    importGLB(url: string): void;
+    clearScene(): void;
+    private _addSky;
+    toggleConfigureInRoom(): void;
+    switchTo2D(): void;
+    switchTo3D(): void;
+    switchToFirstPerson(): void;
+    protected onCameraChanged(): void;
+    protected _setCameraControlListeners(): void;
+    private _onCameraZoomChange;
+    private _setKernelZoomFactor;
+    private _setCeiling;
+    cameraBehaviourChanged(): void;
+    private _updatePaperBackground;
+    sceneChanged(): void;
+    protected _onKeyDown(event: KeyboardEvent): void;
+    private _checkNumKey;
+    protected _onKeyUp(event: KeyboardEvent, cleanup?: boolean): void;
+    setMode(mode: Enumify<typeof CAMERA_TYPE>): void;
+    private _highlightPlanElement;
+    destroy(): void;
+    planObjectConfigurationLoaded(plan: Plan, element: PlanElement, _success: boolean): void;
+    addMesh(_planElement: PlanElement, _material: any, _vertices: Float32Array, _indices: Int32Array, _uvCoords: Float32Array, _normals: Float32Array): void;
+    updateCameraOnDrawWalls(): void;
+    getBounds(): Box3;
+    getGeometryBounds(): Box3;
+    getPlanObject(id: number): KernelPlanObject;
+    /**
+     * This is needed to get the root plan object id in case a plan element is selected
+     * which has been docked using `advanced docking`
+     * @param id
+     */
+    getRootPlanObjectId(id: number): number;
+    cancelPlanElementSelection(reason: CancelSelectionReasons): void;
+    deletePlanElementSelection(): Promise<void>;
+    deletePlanElementByIds(runtimeIds: number[]): Promise<void>;
+    rotatePlanElementSelection(rotateBy: number): void;
+    planBoundsChanged(): void;
+    planElementRemoved(element: PlanElement): void;
+    private _onPlanChanged;
+    prepareTopImage(options?: PrepareImageOptions): Promise<Base64Image>;
+    preparePerspectiveImageOf(runtimeId: RuntimeId, options?: PrepareImageOptions): Promise<Base64Image>;
+    protected _waitForAssets(): Promise<void>;
+    _preparePerspectiveImage(options?: PrepareImageOptionsPlanner, isolationMode?: boolean): Promise<Base64Image>;
+    private _handlePlannerIsolationModeState;
+    private _hideAllExceptSelectedElement;
+    preparePerspectiveImage(options?: PrepareImageOptions, isolationMode?: boolean): Promise<Base64Image>;
+    protected _calculateBoundingBoxOfAllMeshes(spacing?: number): CameraTarget;
+    enableRotation(): void;
+    disableRotation(): void;
+    enableSnapping(): void;
+    disableSnapping(): void;
+    enableAdvancedDocking(): void;
+    disableAdvancedDocking(): void;
+    showsChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): boolean;
+    enableShowChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): void;
+    disableShowChildrenOfPlanObject(planElementViewModel: PlanElementViewModel): void;
+    dragIn(dragEvent: DragEvent): void;
+    getPlannerSceneEventHandler(): PlannerSceneEventHandler;
+    disablePlannerEvents(): void;
+    enablePlannerEvents(): void;
+    protected _onCameraIdle(): boolean;
+    private _hideAllNodeIfThereAreNoSelections;
+    protected _onCameraMove(): boolean;
+    private _showWallNodes;
+    private _updateNodeSize;
+    private _sendPlanObjectPositions;
+    private _sendRoomAreaData;
+    private _updateMeasurementPositions;
+    private _sendElementMeasurements;
+    private _sendRoomMeasurements;
+    private _sendMeasurementLineDimension;
+    private _sendObjectMeasurements;
+    private transformMeasurements;
+    private _sendConstructionElementDimensions;
+    private _sendWallDimensions;
+    enableWallDrawing(): void;
+    disableWallDrawing(): void;
+    escapeDrawing(cancelDrawing: boolean): void;
+    setSceneEvents(sceneEvents: SceneEvents): void;
+    /**
+     * called by kernel
+     */
+    startedDrawing(): void;
+    /**
+     * called by kernel
+     */
+    stoppedDrawing(): void;
+    disableEvents(): void;
+    enableEvents(): void;
+    resetCameraPositionToStart(): void;
+    moveCamera(cameraParameter: CameraParameter): Promise<void>;
+    protected _setInteriorOrExteriorWallMaterial(type: Enumify<typeof SET_WALL_MATERIAL_TYPE>, material: BatchPaintMaterial): void;
+    changeInteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeExteriorWallsMaterial(material: BatchPaintMaterial): void;
+    changeFloorsMaterial(material: BatchPaintMaterial): void;
+    getWallAngleDegrees(wall: WallPlanElementViewModel): number;
+    moveElementPosition(selectedElement: PlanElementViewModel, position: KernelVector3): void;
+    moveElementsPosition(selectedElements: PlanElementViewModel[], position: KernelVector3): void;
+    protected get plannerCameraBehaviour(): Planner2dCameraBehaviour | Planner3dCameraBehaviour | PlannerFpCameraBehaviour;
+    enableMeasurementLineDrawing(): void;
+    disableMeasurementLineDrawing(): void;
+    setCompletelyLoaded(completelyLoaded: boolean): void;
+    protected enablePanning(): void;
+    protected disablePanning(): void;
+    setObjectToWallMeasurementLength(planElementId: number, measurementId: number, length: number): void;
+    setWallMeasurementLength(measurementId: number, length: number, wallDirection: EMSConstant): void;
+    setMeasurementLineLength(measurementId: number, length: number, wallDirection: string): void;
+    protected setEventHandlerObject(object: Object3D): void;
+    protected _readyForRender(): void;
+    protected notifyPlannerOnComponentSelectionCancel(isExternalObject: boolean): void;
+}
+export {};

package/lib/definitions/packages/test-helpers/unit/global-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/definitions/packages/test-helpers/unit/modules-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/definitions/packages/tools-core/src/roomle-tools-core.d.ts

@@ -0,0 +1,37 @@
+import type ScriptLoader from '../../common-core/src/script-loader';
+import type { Context } from '../../common-core/src/di/context';
+import type KernelIo from '../../common-core/src/kernel-io';
+import type { ExternalEmbeddable } from '../../common-core/src/main';
+export interface ToolsCoreContextCallback {
+    isReady(): void;
+    throw(what: string): void;
+    log(message: string): void;
+    error(line: number, column: number, message: string, source: string): void;
+    message(messageObject: MessageObject): void;
+}
+export interface MessageObject {
+    column?: number;
+    fileName: string;
+    line?: number;
+    message: string;
+    type: string;
+}
+export interface ToolsCoreInterface {
+    getVersion(): string;
+    analyzeComponent(componentDefinition: string, componentFilepath: string): void;
+}
+export type ToolsCoreCallback = ToolsCoreContextCallback;
+export interface RoomleToolsCoreUICallback {
+}
+export default class RoomleToolsCore implements Context, ExternalEmbeddable<RoomleToolsCoreUICallback> {
+    _creator_: string;
+    callbacks: RoomleToolsCoreUICallback;
+    _kernelCallbacks: ToolsCoreContextCallback;
+    private _toolsCoreInstance;
+    private _analyzeComponentCallback;
+    protected _scriptLoader: ScriptLoader;
+    protected _kernelIo: KernelIo;
+    constructor(creator: string);
+    init(): Promise<void>;
+    analyzeComponent(componentDefinition: string, source: string): Promise<MessageObject[]>;
+}

package/lib/definitions/packages/tools-core/src/tools-core.d.ts

@@ -0,0 +1,13 @@
+import './utils/global-definitions';
+import Main from '../../common-core/src/main';
+import type RoomleToolsCore from './roomle-tools-core';
+export declare class ToolsCore extends Main {
+    private _tools;
+    protected setupGlobals(): void;
+    protected setupDependencies(): void;
+    protected cleanUpGlobals(): void;
+    protected cleanUpDependencies(): void;
+    protected bootFinished(): void;
+    getApi(): RoomleToolsCore;
+    protected getContextName(): string;
+}

package/lib/definitions/packages/tools-core/src/utils/global-definitions.d.ts

@@ -0,0 +1,7 @@
+import '../../../typings/global-definitions';
+import type RoomleToolsCore from '../roomle-tools-core';
+declare global {
+    interface Window {
+        RoomleToolsCore: RoomleToolsCore;
+    }
+}

package/lib/definitions/packages/tools-core/src/utils/injectables.d.ts

@@ -0,0 +1,2 @@
+import { DependencyInjectionAssignment } from '../../../common-core/src/di/container';
+export declare const INJECTABLES: DependencyInjectionAssignment[];

package/lib/definitions/packages/typings/configurator-kernel-container.d.ts

@@ -0,0 +1,102 @@
+import type { ConfiguratorKernelClass, KernelAddOnSpot, KernelComponent, KernelConfiguration, KernelDockPairToLine, KernelDockPairToPoint, KernelParameter, KernelParameterGroup, KernelParameterValue, KernelParamKeyValuePair, KernelPart, KernelPartListParameter, KernelPossibleChild, KernelRange, KernelVariable, KernelVariant } from './kernel';
+import type { PlanObjectList } from './planner-kernel-container';
+import * as ems from './ems';
+declare const EmsArray: typeof ems.EmsArray;
+declare class DockPairToPointArray extends EmsArray<KernelDockPairToPoint> {
+}
+declare class DockPairToLineArray extends EmsArray<KernelDockPairToLine> {
+}
+declare class ComponentArray extends EmsArray<KernelComponent> {
+}
+declare const enum Type {
+    UNKNOWN = 0,
+    INTEGRAL = 1,
+    DECIMAL = 2,
+    STRING = 3,
+    MATERIAL = 4
+}
+declare const enum UnitType {
+    LENGTH = 0,
+    AREA = 1,
+    ANGLE = 2,
+    COUNT = 3
+}
+declare class VariableArray extends EmsArray<KernelVariable> {
+}
+declare class RangeArray extends EmsArray<KernelRange> {
+}
+declare class ParameterValueArray extends EmsArray<KernelParameterValue> {
+}
+declare class ParameterArray extends EmsArray<KernelParameter> {
+}
+declare class ParameterGroupArray extends EmsArray<KernelParameterGroup> {
+}
+declare class PartListParameterArray extends EmsArray<KernelPartListParameter> {
+}
+declare class ConfigurationArray extends EmsArray<KernelConfiguration> {
+}
+declare class PartArray extends EmsArray<KernelPart> {
+}
+declare class PossibleChildArray extends EmsArray<KernelPossibleChild> {
+}
+declare class AddOnSpotArray extends EmsArray<KernelAddOnSpot> {
+}
+declare class ParamKeyValuePairArray extends EmsArray<KernelParamKeyValuePair> {
+}
+declare class VariantArray extends EmsArray<KernelVariant> {
+}
+declare class IntArray extends EmsArray<number> {
+}
+declare const enum Unit {
+    InchFeet = 0,
+    MM = 1,
+    CM = 2
+}
+declare const enum UnitStringType {
+    NoUnitString = 0,
+    LongUnitString = 1,
+    ShortUnitString = 2
+}
+declare class UnitMeasureFormatter {
+    init(mmLabel: string, cmLabel: string, ftShortLabel: string, ftLongLabel: string, inchShortLabel: string, inchLongLabel: string, sqMLabel: string, sqftLabel: string, showExactValue: boolean, maxPrecision: number, showFractionalUnitString: boolean): void;
+    showExactValues(shouldeI: boolean): void;
+    formatMMValueToUnitString(aValue: number, aUnit: Unit, aStringType: UnitStringType): string;
+    formatMMValueWithReqMaxLength(aValue: number, aUnit: Unit, reqMaxSize: number): string;
+    parseMMValueFromUnitString(aString: string, aUnit: Unit): number;
+    formatSquareMMValueToUnitString(aValue: number, aUnit: Unit): string;
+    parseSquareMMValueFromUnitString(aString: string, aUnit: Unit): number;
+    isParseableUnitString(aString: string, aUnit: Unit): boolean;
+    parseNumber(aString: string): number;
+    formatNumber(aValue: number, digit: number): string;
+    isParseableNumber(aString: string): boolean;
+}
+export interface ConfiguratorKernelContainer {
+    DockPairToPointArray: DockPairToPointArray;
+    DockPairToLineArray: DockPairToLineArray;
+    ComponentArray: ComponentArray;
+    Type: Type;
+    UnitType: UnitType;
+    VariableArray: VariableArray;
+    RangeArray: RangeArray;
+    ParameterValueArray: ParameterValueArray;
+    ParameterArray: ParameterArray;
+    ParameterGroupArray: ParameterGroupArray;
+    PartListParameterArray: PartListParameterArray;
+    ConfigurationArray: ConfigurationArray;
+    PartArray: PartArray;
+    PossibleChildArray: PossibleChildArray;
+    AddOnSpotArray: AddOnSpotArray;
+    PlanObjectList: PlanObjectList;
+    ParamKeyValuePairArray: ParamKeyValuePairArray;
+    VariantArray: VariantArray;
+    IntArray: IntArray;
+    Kernel: ConfiguratorKernelClass;
+    Unit: Unit;
+    UnitStringType: UnitStringType;
+    toUnit: (enumIndex: number) => Unit;
+    toUnitFormat: (enumIndex: number) => UnitStringType;
+    UnitMeasureFormatter: UnitMeasureFormatter;
+    registerConfiguratorCallback: (callbacksObject: any) => void;
+    unregisterConfiguratorCallback: (callbacksObject: any) => void;
+}
+export {};

package/lib/definitions/packages/typings/ems.d.ts

@@ -0,0 +1,27 @@
+export declare class EmsArray<T> {
+    get(index: number): T;
+    push_back(element: T): void;
+    resize(from: number, to: number): void;
+    set(index: number, element: T): T;
+    size(): number;
+    clone(index: number): EmsArray<T>;
+    delete(index: number): void;
+    deleteLater(index: number): void;
+    isAliasOf(index: number): boolean;
+    isDeleted(index: number): boolean;
+}
+export declare class EmsList<T> {
+    push_back(element: T): void;
+    size(): number;
+    get(index: number): T;
+}
+export declare class EmsSet<T> {
+    insert(element: T): void;
+    size(): number;
+}
+export declare class InternalError {
+}
+export declare class BindingError {
+}
+export declare class UnboundTypeError {
+}

package/lib/definitions/packages/typings/global-definitions.d.ts

@@ -0,0 +1,33 @@
+import type * as __dat from 'dat.gui';
+import type * as __THREE from 'three';
+import type SceneManager from '../common-core/src/webgl/scene-manager';
+interface Debug {
+    raycaster?: boolean;
+    camera?: boolean;
+    boundingBox?: boolean;
+    PlannerKernelContainer?: any;
+    ConfiguratorKernel?: any;
+    Kernel?: any;
+    KernelContainer?: any;
+    Helper?: any;
+    SceneManager?: SceneManager;
+    interactionTimingMs?: number;
+}
+type ThreeShader = string;
+declare global {
+    const THREE: typeof __THREE;
+    const dat: typeof __dat;
+    const WebAssembly: any;
+    interface Window {
+        KernelCallback: {
+            isReady: () => void;
+        };
+        __RML_GUI__: dat.GUI;
+        __RML__DEBUG__: Debug;
+        _rsl: {
+            [key: string]: ThreeShader;
+        };
+    }
+}
+declare const _default: {};
+export default _default;

package/lib/definitions/packages/typings/helper.d.ts

@@ -0,0 +1,2 @@
+export type Values<T> = T[keyof T];
+export type Nullable<T> = T | null;