@roomle/embedding-lib 5.24.0 → 5.25.0-alpha.2

package/packages/web-sdk/packages/configurator-core/src/services/configurator-kernel-access-callback.d.ts

@@ -0,0 +1,20 @@
+import { KernelParameter, KernelParameterGroup, KernelPossibleChild } from '../../../typings/kernel';
+import { PARAMETER_UPDATE_TYPE } from '../roomle-configurator';
+import { KernelAccessCallbackI } from '../../../common-core/src/kernel-access-callback';
+import { Context } from '../../../common-core/src/di/context';
+
+export interface ConfiguratorKernelAccessCallbackI extends KernelAccessCallbackI {
+    updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): void;
+    updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
+}
+export default class ConfiguratorKernelAccessCallback implements Context, ConfiguratorKernelAccessCallbackI {
+    _creator_: string;
+    private _callbackListener;
+    constructor(creator: string);
+    addListener(listener: ConfiguratorKernelAccessCallbackI): void;
+    removeListener(listener: ConfiguratorKernelAccessCallbackI): void;
+    isReady(): void;
+    updatePossibleChildren(elementId: number, children: KernelPossibleChild[], parameterUpdateType?: PARAMETER_UPDATE_TYPE): void;
+    updateParameters(parameters: KernelParameter[], parameterGroups: KernelParameterGroup[], elementId: number | number[], parameterUpdateType: PARAMETER_UPDATE_TYPE): void;
+    loadError(error?: any): void;
+}

package/packages/web-sdk/packages/configurator-core/src/services/configurator-ui-callback.d.ts

@@ -0,0 +1,296 @@
+import { ConfiguratorKernelClass, DebugValueMapChange, KernelComponent, KernelCube, KernelPartList, KernelVector3, UiKernelParameter, UiPossibleChild, UiPossibleChildTag } from '../../../typings/kernel';
+import { UIIntersection } from '../utils/ui-intersection-helper';
+import { RAPI_PATHS } from '../../../common-core/src/rapi-access';
+import { ConfigurationHash, RapiId, RapiTagForUi } from '../../../typings/rapi-types';
+import { UiCallback } from '../../../common-core/src/utils/ui-callback';
+import { ConfiguratorKernelContainer } from '../../../typings/configurator-kernel-container';
+import { PlannerKernelContainer } from '../../../typings/planner-kernel-container';
+import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { ConfiguratorDebugCallbacks } from '../configurator-debug-api';
+import { CancelSelectionReasons } from '../../../typings/planner';
+
+export type ComponentAction = 'edit' | 'add';
+export type ComponentType = 'preview' | 'component';
+export interface UIComponentInfo {
+    id: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    type: ComponentType;
+    actions: ComponentAction[];
+}
+export default class ConfiguratorUiCallbacks extends UiCallback implements ConfiguratorDebugCallbacks {
+    /**
+     * When kernel initialization is complete
+     */
+    onKernelIsReady: () => void;
+    /**
+     * gets called when the screen position of components/previews changes
+     * @param positions
+     */
+    onComponentPositionsUpdated: (positions: UIComponentInfo[]) => void;
+    /**
+     * When component parameters are changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param parameters
+     */
+    onUpdateParameters: (parameters: UiKernelParameter[]) => void;
+    /**
+     * When children of a component change, this event is triggered
+     * on start up and when a configuration changes
+     * @param tags
+     * @param defaultChild
+     */
+    onUpdatePossibleChildren: (tags: UiPossibleChildTag[], defaultChild: UiPossibleChild) => void;
+    /**
+     * When the price of a configuration/item changes, this event is triggered
+     * on start up and when a configuration changes
+     * @param currencySymbol
+     * @param price
+     */
+    onUpdatePrice: (currencySymbol: string, price: number) => void;
+    /**
+     * When a/another (different) component has been selected
+     * @param selectionMode
+     * @param isRoot
+     * @param hasChildren
+     * @param components
+     */
+    onSelectionChange: (selectionMode: string, isRoot: boolean, hasChildren: boolean, components: KernelComponent[]) => void;
+    /**
+     * When a component or item selection has been canceled
+     */
+    onSelectionCancel: (reason: CancelSelectionReasons) => void;
+    /**
+     * When part list has been changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param partList
+     * @param hash
+     */
+    onPartListUpdate: (partList: KernelPartList, hash: ConfigurationHash) => void;
+    /**
+     * When the bounds of the object are changed/updated, this event is triggered
+     * on start up and when a configuration changes
+     * @param bounds
+     */
+    onBoundsUpdate: (bounds: {
+        width: string;
+        height: string;
+        depth: string;
+        kernelBounds: KernelCube;
+    }) => void;
+    /**
+     * When a new item or configuration is loading, this can be useful to display loading screens etc
+     */
+    onLoadConfiguration: () => void;
+    /**
+     * When configuration has been loaded completely, this can be useful to hide loading indicators
+     * @param partList
+     * @param hash
+     * @param rootComponentLabel
+     */
+    onConfigurationReady: (partList: KernelPartList, hash: ConfigurationHash, rootComponentLabel: string) => void;
+    /**
+     * When UI should show the overlay based on the selected tag. Gets triggered when {@link @roomle/web-sdk/configurator-core/src/utils/shims#CommonInitData.startTag} is set
+     * @param tag
+     */
+    onOpenTag: (tag: RapiTagForUi) => void;
+    /**
+     * When UI should show add ons
+     */
+    onOpenAddOns: () => void;
+    /**
+     * When the user clicks on no UI element, can be used to deselect
+     */
+    onClickOutside: () => void;
+    /**
+     * Is triggered when {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.previewDockings} has no available dockings
+     */
+    onNoDockingsAvailable: () => void;
+    /**
+     * When the configuration overlaps the UI (defined by {@link @roomle/web-sdk/configurator-core/src/configurator-interfaces#CanvasOffset})
+     * @param intersections
+     */
+    onUiIntersectionChange: (intersections: UIIntersection[]) => void;
+    /**
+     * When the zoom level has been changed by the user
+     * @param minZoom true when zoomed out as far as possible
+     * @param maxZoom true when zoomed in as much as possible
+     */
+    onZoomChange: (minZoom: boolean, maxZoom: boolean) => void;
+    /**
+     * When the use clicks on a configurable element twice to zoom the camera onto said element.
+     * Doesn't matter if triggered by the user or via SDK
+     */
+    onZoomToComponent: () => void;
+    /**
+     * When the visibility of the dimensions changes from visible to gone or vice versa.
+     * Doesn't matter if triggered by the user or via SDK
+     * @param visible
+     */
+    onDimensionsVisibilityChange: (visible: boolean) => void;
+    /**
+     * When not connected to the internet
+     * @param error
+     */
+    onErrorDueToOffline: (error: Error) => void;
+    /**
+     * When any generic error is thrown while requesting data
+     * @param error
+     */
+    onError: (error: Error) => void;
+    /**
+     * Fires after an element has been docked
+     * @param component the child component that was docked to the parent component
+     * @param id the runtime id of the child component
+     */
+    onElementDocked: (component: KernelComponent, id: number) => void;
+    /**
+     * When dockings/ghosts are no longer visible
+     */
+    onDockingsPreviewRemoved: () => void;
+    /**
+     * Updates when the current configuration changes
+     * @param hasChildren
+     */
+    onConfigurationHasChildren: (hasChildren: boolean) => void;
+    /**
+     * This method is used to track timings, this can be helpful to identify performance bottel necks
+     * @hidden
+     * @param category
+     * @param label
+     * @param time
+     * @param meta
+     */
+    onTrackTiming: (category: string, label: string, time: number, meta: object) => void;
+    /**
+     * When a dock component call has been completed
+     * @param childDbId the database id of the component which is docked
+     * @param childDockId the number of the dock position
+     * @param parentDbId the database id of the component to which is docked
+     * @param parentDockId the number of the dock position to which is docked
+     * @param position vector where the dock is done can be null
+     */
+    onUserInitiatedDockDone: (childDbId: RapiId, childDockId: number, parentDbId: RapiId, parentDockId: number, position: KernelVector3) => void;
+    /**
+     * When user hovers over an addon plus symbol
+     */
+    onAddonPlusHover: () => void;
+    /**
+     * When user hovers over an addon plus symbol
+     */
+    onAddonPlusHoverOff: () => void;
+    /**
+     * When all addon plus symbols are shown in the user interface
+     */
+    onAddonPlusShown: () => void;
+    /**
+     * When all addon plus symbols are hidden in the user interface
+     */
+    onAddonPlusHidden: () => void;
+    /**
+     * When an asset could not be loaded (for example an image or texture). See paths or ids to identify the problem.
+     * @param data
+     */
+    onContentProblem: (data: {
+        rapiPath: RAPI_PATHS;
+        ids: RapiId[];
+        message: string;
+    }) => void;
+    /**
+     * When a sync has been started
+     */
+    onSyncStarted: () => void;
+    /**
+     * When a previously requested sync has been completed
+     */
+    onSyncDone: () => void;
+    /**
+     * When UI should show floor material selection
+     */
+    onOpenFloorMaterials: () => void;
+    /**
+     * When UI should show part list
+     */
+    onOpenPartList: () => void;
+    /**
+     * When a requested component could not be loaded from RAPI
+     * @param error
+     * @param id
+     */
+    onComponentLoadError: (error: Error, id: RapiId) => void;
+    /**
+     * Gets called when configuration/configurable-item could not be loaded
+     */
+    onConfigurationLoadError: () => void;
+    /**
+     * When {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.changeTypeChangeTag} as been called and the sync has been started
+     * @param rapiId
+     */
+    onChangeTypeChangeTag: (rapiId: RapiId) => void;
+    /**
+     * When {@link @roomle/web-sdk/configurator-core/src/roomle-configurator#RoomleConfigurator.removeTypeChangeTag} as been called
+     * @param rapiId
+     */
+    onRemoveTypeChangeTag: (rapiId: RapiId) => void;
+    /**
+     * Gets called when a new item/configuration has been loaded
+     * @param catalogName
+     * @param rapiItemLabel
+     * @param rootComponentLabel
+     */
+    onConfigurationLabelChange: (catalogName: string, rapiItemLabel: string, rootComponentLabel: string) => void;
+    /**
+     * When kernel failed to load a mesh
+     */
+    onMemoryCorruption: () => void;
+    /**
+     * is called when the configurator kernel is ready. It returns the container and the instance
+     * @param kernelContainer
+     * @param kernelInstance
+     */
+    onConfiguratorKernelIsReady: (kernelContainer: ConfiguratorKernelContainer | PlannerKernelContainer, kernelInstance: ConfiguratorKernelClass) => void;
+    /**
+     * is called when the configuration is saved to our backend
+     */
+    onConfigurationSaved: (configurationHash: ConfigurationHash) => void;
+    /**
+     * called when camera position starts to change or is changing at the moment
+     */
+    onCameraPositionChanges: () => void;
+    /**
+     * gets called if history changes
+     * @param undo true if undo is possible
+     * @param redo true if redo is possible
+     */
+    onHistoryChange: (undo: boolean, redo: boolean) => void;
+    /**
+     * This function gets called when a selectable component on a configurable element has been clicked on.
+     * An equivalent function for component clicks is onClickElement in the roomle-planner-ui-callback.ts
+     * @param component RoomleComponent instance of the clicked component
+     */
+    onClickComponent: (component: RoomleComponent) => void;
+    /**
+     * This function gets called when an external mesh is requested
+     * @param meshId meshId
+     * @param quality number between 0 and 100
+     * @returns void
+     */
+    onRequestExternalMesh: (meshId: string, quality: number) => void;
+    /**
+     * This function gets called when a geometry is ready
+     * @param runtimeId number
+     * @returns void
+     */
+    onGeometryReady: (runtimeId: number) => void;
+    /**
+     * This function gets called when a geometry is not ready
+     * @param runtimeId
+     * @returns
+     */
+    onGeometryNotReady: (runtimeId: number) => void;
+    onValueMapChanged: (changes: DebugValueMapChange) => void;
+    constructor(creator: string);
+}

package/packages/web-sdk/packages/configurator-core/src/services/unit-formatter.d.ts

@@ -0,0 +1,47 @@
+import { KernelParameter, KernelPartListParameter, UiKernelParameter } from '../../../typings/kernel';
+import { Context } from '../../../common-core/src/di/context';
+
+export declare const MEASUREMENT_SYSTEM_STRING: {
+    IMPERIAL: string;
+    METRIC: string;
+};
+export default class UnitFormatter implements Context {
+    _creator_: string;
+    _actualUnitString: string;
+    private _actualMeasurementString;
+    private _initData;
+    private _plannerKernelAccess;
+    private _formatter;
+    private _actualUnit;
+    private _actualUnitStringType;
+    private _precision;
+    constructor(creator?: string);
+    init(kernelContainer: any): void;
+    private _initMeasurementSystemType;
+    private _initActualUnit;
+    private _getKernelUnitEnum;
+    private _initActualUnitStringType;
+    private _isFormatterReady;
+    formatAngleValueToUnitString(value: number, parameter: KernelParameter): string;
+    parseAngleValueFromUnitString(rotation: string): string;
+    parseValue(value: string, parameter: KernelParameter): string | number;
+    formatValueToUnitString(value: number, parameter: KernelParameter): string | number;
+    isParseableNumber(aString: string): boolean;
+    isParseableUnitString(aString: string, parameter: KernelParameter): boolean;
+    parseMMValueFromUnitString(aString: string, unitType: string): number;
+    parseNumber(aString: string): number;
+    formatNumber(aValue: number, digit?: number): string;
+    formatSquareMMValueToUnitString(aValue: number): string;
+    formatMMValueToUnitString(aValue: number, unitType?: string): string;
+    formatMMValueWithReqMaxLength(aValue: number, reqMaxSize: number): string;
+    private _formatParameterValue;
+    formatPartListParameter(parameter: KernelPartListParameter): void;
+    formatParameter(parameter: UiKernelParameter): void;
+    isInch(): boolean;
+    getActualUnitString(): string;
+    getActualMeasurementString(): string;
+    getUnitStringType(): string;
+    getPrecision(): number;
+    getAllowedDelta(): number;
+    setUnitInitData(unit: string, measurementSystem?: string): void;
+}

package/packages/web-sdk/packages/configurator-core/src/static-files/fonts.d.ts

@@ -0,0 +1,2 @@
+export { default as LATO_SUB_FILE_NAME } from '../../public/fonts/lato_regular_sub.json';
+export { default as LATO_FILE_NAME } from '../../public/fonts/lato_regular.json';

package/packages/web-sdk/packages/configurator-core/src/static-files/geometries.d.ts

@@ -0,0 +1 @@
+export { default as BANANA_FILE_NAME } from '../../public/geometry/banana.glb?url';

package/packages/web-sdk/packages/configurator-core/src/static-files/settings.d.ts

@@ -0,0 +1 @@
+export { default as DEFAULT_EXTERNAL_OBJECT_API_CONFIGURATION } from '../../public/settings/default-external-object-api-configuration.json?url';

package/packages/web-sdk/packages/configurator-core/src/static-files/textures.d.ts

@@ -0,0 +1 @@
+export { default as WHITE_WALL_TEXTURE_FILE_NAME } from '../../public/textures/white_wall_texture.jpg';

package/packages/web-sdk/packages/configurator-core/src/utils/animation/animation-helper.d.ts

@@ -0,0 +1,5 @@
+import { RoomleComponent } from '../../../../common-core/src/webgl/roomle-component-factory';
+import { KernelParameter } from '../../../../typings/kernel';
+
+export declare const updateComponentAnimationParameters: (components: RoomleComponent[], parameters: KernelParameter[]) => void;
+export declare const changeComponentAnimationValueAndAnimate: (component: RoomleComponent, parameterKey: string, value: string, level: number, animate: boolean, invalidateRenderCallback: () => void) => void;

package/packages/web-sdk/packages/configurator-core/src/utils/animation/animation-value-map.d.ts

@@ -0,0 +1,17 @@
+import { KernelParameter } from '../../../../typings/kernel';
+
+export declare class AnimationValueMap {
+    private valueMap;
+    static filterAnimationParameters(parameters: KernelParameter[]): KernelParameter[];
+    static getAnimationName(parameterKey: string): string;
+    static getKeyAndValue(animationName: string): {
+        key: string;
+        value: string;
+    };
+    hasKeyAndValue(animationKeyAndValue: string): boolean;
+    updateParameterValue(parameter: KernelParameter): void;
+    setValue(animationName: string, value: string, level: number): void;
+    setValueAndGetOldValue(animationName: string, value: string, level: number): string;
+    getPriorAnimations(animationName: string, level: number): string[];
+    getSequentAnimations(animationName: string, level: number): string[];
+}

package/packages/web-sdk/packages/configurator-core/src/utils/animation/drag-insert-animation.d.ts

@@ -0,0 +1,18 @@
+import { PreviewComponent, RoomleComponent } from '../../../../common-core/src/webgl/roomle-component-factory';
+import { KernelDockPairToPoint } from '../../../../typings/kernel';
+
+export declare class DragInsertAnimation {
+    private _id;
+    private _previewComponent;
+    private _displacedComponent;
+    private _displacementTransformation;
+    private _invalidateRenderCallback;
+    private _currentAnimation;
+    constructor(id: string, previewComponent: PreviewComponent, displacedComponents: RoomleComponent, dockPair: KernelDockPairToPoint, invalidateRenderCallback: () => void);
+    private _addObjectAnimationTransformations;
+    private _addObjectAnimationValue;
+    startInsert(): void;
+    endInsert(): void;
+    cleanUp(): void;
+    private _changeAnimation;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/animation/object-animations.d.ts

@@ -0,0 +1,21 @@
+import { Object3D, Matrix4 } from 'three';
+import { KernelMeshAnimation } from '../../../../typings/kernel';
+import { AnimationTransition, RoomleComponent } from '../../../../common-core/src/webgl/roomle-component-factory';
+
+export interface AnimationTransformation {
+    matrix: Matrix4;
+    visible: boolean;
+    initial: boolean;
+}
+export type AnimationTransformationMap = Map<string, AnimationTransformation>;
+export declare class ObjectAnimations {
+    private animationMap;
+    static setObjectAnimations(object3d: Object3D, animations?: Record<string, KernelMeshAnimation>, component?: RoomleComponent): void;
+    static addObjectAnimations(object3d: Object3D, animations?: AnimationTransformationMap, component?: RoomleComponent): void;
+    static removeObjectAnimations(object3d: Object3D, animationName: string): void;
+    static animateObject(object3d: Object3D, animationName: string, animationTransition: AnimationTransition, animate?: boolean, onProgressUpdate?: () => void): import('@tweenjs/tween.js').Tween<any>;
+    private _animate;
+    private _calculateCombinedAnimationMatrix;
+    private _calculateAnimationTransformation;
+    private _animateMesh;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/async-dependency-loader.d.ts

@@ -0,0 +1,9 @@
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+
+export default class AsyncDependencyLoader {
+    private static loader;
+    private static getLoader;
+    static parseFont(fontData: any): Font;
+    static loadFont(path: string): Promise<Font>;
+    private static _resolveAll;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/async-helper.d.ts

@@ -0,0 +1,12 @@
+export declare const enum ASYNC_OPERATIONS {
+    COMPONENT_DEFINITION_LOADED = 0,
+    KERNEL_SERIALIZED_CONFIGURATION = 1,
+    KERNEL_PLAN_OBJECT_CONSTRUCTION_DONE = 2,
+    UI_RELOAD_CONFIGURATION = 3,
+    CONFIGURATION_LOADED = 4
+}
+export default class AsyncHelper {
+    static finishOperation(operationType: ASYNC_OPERATIONS, data?: any): void;
+    static failOperation(operationType: ASYNC_OPERATIONS, data: Error): void;
+    static waitFor(operationType: ASYNC_OPERATIONS, startCommand?: () => void): Promise<any>;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/component-dimensioning-helper.d.ts

@@ -0,0 +1,25 @@
+import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { Context } from '../../../common-core/src/di/context';
+import { PerspectiveCamera } from 'three';
+
+export default class ComponentDimensioningHelper implements Context {
+    _creator_: string;
+    private _plannerKernelAccess;
+    private _initData;
+    private _camera;
+    private _activeComponents;
+    private _componentDimensioningsExist;
+    constructor(creator: string);
+    setCamera(camera: PerspectiveCamera): void;
+    add(component: RoomleComponent): boolean;
+    private _assembleDimensionings;
+    private _findAxis;
+    private _mapDimensioningToAxis;
+    private _transformObjectDimensioning;
+    private _transformDimensioningScale;
+    private _transformPosition;
+    remove(component: RoomleComponent, remove?: boolean): Promise<void>;
+    hasComponentDimensions(): boolean;
+    reset(): Promise<void>;
+    invalidateDimensioningsCache(componentRuntimeId?: number): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/component-dimensioning.d.ts

@@ -0,0 +1,31 @@
+import { Dimensioning, DimensioningAxis } from '../../../typings/kernel';
+import { Box3, Object3D, Vector3 } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
+
+export interface DimensioningAndAxis {
+    dimensioning: Dimensioning;
+    axis?: DimensioningAxis;
+}
+export default class ComponentDimensioning extends Object3D {
+    private _cacheHolder;
+    private _unitFormatter;
+    private _dimensioning;
+    private _axis;
+    private _size;
+    private _relativeCameraDirection;
+    private _font;
+    private _level;
+    private _line;
+    private _text;
+    private _plane;
+    private _lineMaterial;
+    private _planeMaterial;
+    private _textMaterial;
+    constructor(dimensioningAndAxis: DimensioningAndAxis, boundingBox: Box3, font: Font, relativeCameraDirection: Vector3);
+    clone(): any;
+    private _initMaterials;
+    private _init;
+    private _addEdgeSideLines;
+    private _addLine;
+    private _addText;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/component-raycast-helper.d.ts

@@ -0,0 +1,23 @@
+import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { default as ConfiguratorSceneEventHandler } from '../webgl/configurator-scene-event-handler';
+import { default as ConfiguratorViewModel } from '../../../common-core/src/view-model/configurator-view-model';
+import { Object3D, PerspectiveCamera } from 'three';
+
+export default class ComponentRaycastHelper {
+    private _object;
+    private _camera;
+    private _raycaster;
+    private _nonTransparentComponent;
+    constructor();
+    init(object: Object3D, camera: PerspectiveCamera): void;
+    setCamera(camera: PerspectiveCamera): void;
+    setObject(object: Object3D): void;
+    changeMaterialsOnSelect(object: Object3D, component: RoomleComponent, selected?: boolean, callback?: () => void): Promise<void>;
+    private _changeMaterialsOnSelect;
+    isComponentVisible(component: RoomleComponent): boolean;
+    checkComponentAndPreviewVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;
+    checkComponentVisibility(sceneEventHandler: ConfiguratorSceneEventHandler, configuratorViewModel: ConfiguratorViewModel): void;
+    areAllPreviewsVisible(configuratorViewModel: ConfiguratorViewModel): boolean;
+    areAllComponentsInFrustum(previews: RoomleComponent[]): boolean;
+    checkPreviewVisibility(configuratorViewModel: ConfiguratorViewModel): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/configurator-history.d.ts

@@ -0,0 +1,48 @@
+import { Context } from '../../../common-core/src/di/context';
+import { ConfigurationString } from '../../../typings/rapi-types';
+
+export default class ConfiguratorHistory implements Context {
+    _creator_: string;
+    private _history;
+    private _index;
+    private _configuratorUiCallbacks;
+    constructor(creator: string);
+    /**
+     * loads the configurationString of the configuration which was set before
+     * only possible if there are some changes on the current item
+     * @returns configurationString of lastAction or null if canUndo returns false
+     */
+    undo(): ConfigurationString | null;
+    /**
+     * loads the configurationString of the configuration which was set before undo function was called
+     * only possible if undo function was called before
+     * @returns configurationString of configuration before undo was called or null if canRedo returns false
+     */
+    redo(): ConfigurationString | null;
+    /**
+     * pushes new configurationString to history Array
+     * is called when changes on the item happened
+     * @param configurationString
+     * @returns
+     */
+    push(configurationString: ConfigurationString): void;
+    /**
+     * checks if there are any changes on the item already happened
+     * @returns true if the current configuration is not the default configuration
+     */
+    canUndo(): boolean;
+    /**
+     * checks if there are newer configurations
+     * @returns true if current configuration is not the latest configuration
+     */
+    canRedo(): boolean;
+    /**
+     * @returns array of all configuration strings
+     */
+    getHistory(): string[];
+    /**
+     * clears history and make new empty history array
+     * sets index on 0 that no undo and redo is possible
+     */
+    clearHistory(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/dimensioning-helper.d.ts

@@ -0,0 +1,61 @@
+import { Object3D, Scene, Box3, Vector3 } from 'three';
+import { KernelCube } from '../../../typings/kernel';
+
+export default class DimensioningHelper {
+    _creator_: string;
+    private _unitFormatter;
+    private _uiScene;
+    private _object;
+    private _objectRotation;
+    private _cameraPosition;
+    private _font;
+    private _onChange;
+    private _topDimensions;
+    private _initialized;
+    private _origin;
+    private _dimensions;
+    private _lineMaterial;
+    private _planeMaterial;
+    private _widthLine;
+    private _heightLine;
+    private _depthLine;
+    private _widthText;
+    private _heightText;
+    private _depthText;
+    private _enabled;
+    private _dimensionsVisible;
+    private _dimensionLineGroup;
+    private _dimensionTextGroup;
+    constructor(creator: string);
+    private _loaded;
+    private _performUpdate;
+    private _updateWidth;
+    private _updateHeight;
+    private _updateDepth;
+    updateSize(boxForMeasurement: KernelCube): void;
+    update(force?: boolean): void;
+    addToObject(object: Object3D): void;
+    removeFromObject(object: Object3D): void;
+    addToUiScene(uiScene: Scene): void;
+    removeFromUiScene(uiScene: Scene): void;
+    private _getWidthEdge;
+    private _getDepthEdge;
+    private _getHeightEdge;
+    onDimensionsVisibilityChanged(handler: (visible: boolean) => void): void;
+    enableTopDimensions(): void;
+    disableTopDimensions(): void;
+    enableDimensions(): void;
+    disableDimensions(): void;
+    private _visibilityChangedCallback;
+    _clear(): void;
+    getBoundingBox(): Box3;
+    private setVisibility;
+    moveCameraStart(position: Vector3): void;
+    moveCameraEnd(position: Vector3): void;
+    clearScene(_scene: Scene): void;
+    setObject(object: Object3D, rotation?: number): void;
+    setUiScene(uiScene: Scene): void;
+    isInitialized(): Promise<void>;
+    areDimensionsEnabled(): boolean;
+    private _getRotation;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/error-messages.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    NO_MATERIAL_ID: string;
+};
+export default _default;