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

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

@@ -0,0 +1,17 @@
+type ListenerFunction<T> = (arg: T) => void;
+export interface Listener<T> {
+    key: number;
+    fun: ListenerFunction<T>;
+}
+export default class EventDispatcher<T> {
+    private _listeners;
+    private _disabled;
+    private _addEventListener;
+    hasEventListener(eventName: number, callback: ListenerFunction<T>, scope: any): boolean;
+    addEventListener(eventName: number, callback: ListenerFunction<T>, scope: any): void;
+    dispatchEvent(eventName: number, arg?: T): void;
+    removeEventListener(eventName: number, fun: ListenerFunction<T>): void;
+    enableEvents(): void;
+    disableEvents(): void;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { default as RoomleConfigurator } from '../roomle-configurator';
+
+declare global {
+    interface Window {
+        ConfiguratorKernel: any;
+        RoomleConfigurator: RoomleConfigurator;
+    }
+}

package/packages/web-sdk/packages/configurator-core/src/utils/imos-ix-poc-export-helper.d.ts

@@ -0,0 +1,44 @@
+import { ConfigurationExporter, ConfiguratorKernelClass, ExportType } from '../../../typings/kernel';
+import { PlanOverview } from '../../../typings/planner';
+
+export interface HomagIxOrderParams {
+    orderNumber?: string;
+    dispatchDate?: string;
+    basketNumber?: string;
+}
+export interface HomagIxHeaderParams {
+    comm?: string;
+    articleno?: string;
+    customer?: string;
+    retailer?: string;
+    client?: string;
+    program?: string;
+    employee?: string;
+    textLong?: string;
+    textShort?: string;
+    colour?: string[];
+    info?: string[];
+    address?: string[];
+    billingAddress?: string[];
+    shippingAddress?: string[];
+    orderPriceInfo?: string[];
+    customInfo?: string[];
+}
+export interface HomagIxArticleParams {
+    articleTextInfo1?: string;
+    articleTextInfo2?: string;
+    articlePriceInfo1?: string;
+    articlePriceInfo2?: string;
+    articlePriceInfo3?: string;
+    deliveryPeriod?: string;
+    supplier?: string;
+    discount?: number;
+    discountAbs?: number;
+}
+export declare const createHomagIxXml: (orderData: HomagIxOrderParams, headerData: HomagIxHeaderParams, articleShopData: HomagIxArticleParams, articleCoreData: any) => string;
+export declare const getFakeOrderParams: () => HomagIxOrderParams;
+export declare const getFakeHeaderParams: () => HomagIxHeaderParams;
+export declare const getFakeArticleParams: () => HomagIxArticleParams;
+export declare const downloadHomagIxExportPoC: (planOverview: PlanOverview, exporter: ConfigurationExporter, kernelInstance: ConfiguratorKernelClass) => Promise<void>;
+export declare const generateExportHomagIxConfiguration: (planObjectId: number, exportType: ExportType, exporter: ConfigurationExporter, kernelInstance: ConfiguratorKernelClass, defaultExportDefinition?: string) => Promise<any>;
+export declare const homagIxMockUpData: (articles: any[], homagIxOrderData?: {}, homagIxHeaderParams?: {}, homagIxArticleParams?: {}) => string;

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

@@ -0,0 +1,10 @@
+import { WasmDbEntry } from '../../../typings/kernel';
+
+export declare const NOT_FOUND_ERROR = "404";
+export default class IndexedDbAdapter {
+    static openDb(dbName: string, dbVersion: number, upgradeDbCallback: (this: IDBOpenDBRequest, ev: IDBVersionChangeEvent) => any): Promise<IDBDatabase>;
+    static getObjectStore(dbConnection: IDBDatabase, storeName: string, transactionMode: IDBTransactionMode): IDBObjectStore;
+    static getRecordFromObjectStore(dbConnection: IDBDatabase, storeName: string, recordId: string): Promise<WasmDbEntry>;
+    static deleteRecordFromObjectStore(dbConnection: IDBDatabase, storeName: string, recordId: string): Promise<void>;
+    static saveRecordToObjectStore(dbConnection: IDBDatabase, storeName: string, objRecord: WasmDbEntry): Promise<void>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { KernelParameter, KernelPartListParameter } from '../../../typings/kernel';
+
+export declare const enum PARAMETER_UI_TYPES {
+    RANGE = "Range",
+    BOOLEAN = "Boolean",
+    MATERIAL = "Material",
+    OPTIONS = "Options",
+    THUMBNAILS = "Thumbnails"
+}
+export declare const isRange: (parameter: KernelParameter) => boolean;
+export declare const isOptions: (parameter: KernelParameter) => boolean;
+export declare const hasUnits: (parameter: KernelParameter | KernelPartListParameter) => boolean;
+export declare const isThumbnail: (parameter: KernelParameter) => boolean;
+export declare const isBoolean: (parameter: KernelParameter) => boolean;
+export declare const isMaterial: (parameter: KernelParameter | KernelPartListParameter) => boolean;

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

@@ -0,0 +1,10 @@
+import { ExternalConfiguration } from '../../../typings/external-objects';
+import { RapiConfigurationEnhanced } from '../../../typings/rapi-types';
+
+export type PluginName = 'external-objects';
+interface PluginConfigMap {
+    'external-objects': RapiConfigurationEnhanced | ExternalConfiguration;
+}
+type ConfigForPlugin<P extends PluginName> = PluginConfigMap[P];
+export type SaveCurrentConfigurationReturnType<P extends readonly PluginName[]> = P['length'] extends 0 ? RapiConfigurationEnhanced : P[number] extends infer T ? T extends PluginName ? ConfigForPlugin<T> : never : never;
+export {};

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

@@ -0,0 +1,82 @@
+import { default as InputManager, InputEvent } from '../../../common-core/src/input/input-manager';
+import { SceneEventInfo } from '../webgl/configurator-scene-event-handler';
+import { default as EventDispatcher } from './event-dispatcher';
+import { RoomleEventedMesh } from '../../../common-core/src/utils/threejs-utils';
+import { Camera, Layers, Object3D, Scene, Vector3 } from 'three';
+
+export declare const enum OBJECT_EVENT {
+    CLICK = "select",
+    DOUBLE_CLICK = "double_click",
+    HOVER_ON = "hover_on",
+    HOVER_OFF = "hover_off",
+    HOVER_MOVE = "hover_move",
+    DRAG_START = "drag_start",
+    DRAG = "drag",
+    DRAG_END = "drag_end",
+    ROTATE = "rotate"
+}
+export declare const RAYCAST_PRIORITY: {
+    readonly RAYCASTER_FLOOR: 0.8;
+    readonly FLOOR: 0.9;
+    readonly WALL: 0.95;
+    readonly DEFAULT: 1;
+    readonly CONSTRUCTION: 1;
+    readonly COMPONENT: 2;
+    readonly PREVIEW: 3;
+    readonly PREVIEW_LINE: 4;
+};
+export declare const enum INTERSECTION_MODE {
+    PLANNER = 0,
+    CONFIGURATOR = 1
+}
+export declare const enum RAYCAST_EVENT {
+    CLICK_OUTSIDE = 0
+}
+export default class RaycastHelper extends EventDispatcher<SceneEventInfo> {
+    private _mode;
+    private _object;
+    private _camera;
+    private _inputManager;
+    private _raycaster;
+    private _bounds;
+    private _rootComponentId;
+    private _rootComponentPosition;
+    private _backgroundScene;
+    private _currentHover;
+    private _currentDrag;
+    private _currentRotate;
+    private _offset;
+    private _planeFront;
+    private _planeBottom;
+    private _planeSide;
+    private _lastMoveCheck;
+    private _onWallSnapping;
+    constructor(object: Object3D, camera: Camera, generalInput: InputManager, mode?: INTERSECTION_MODE);
+    setLayers(layers: Layers): void;
+    getLayers(): Layers;
+    private _addInputListeners;
+    private _findCandidate;
+    private _findSelection;
+    private _findHover;
+    private _intersection;
+    private _intersect;
+    private _findObjectWithHandler;
+    private _onDragStart;
+    private _onDrag;
+    private _getIntersectionPosition;
+    private _getDistanceToCamera;
+    private _onDragEnd;
+    private _onRotate;
+    private _positionPlanes;
+    private _calculateOffset;
+    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    clear(): void;
+    enableDragIn(mesh: RoomleEventedMesh): void;
+    setRootComponentId(rootComponentId: number): void;
+    setCamera(camera: Camera): void;
+    setObject(object: Object3D): void;
+    setMode(mode: INTERSECTION_MODE): void;
+    intersectMouseOnScene(event: InputEvent): import('../../../typings/kernel').KernelVector3;
+    enableOnWallSnapping(): void;
+    disableOnWallSnapping(): void;
+}

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

@@ -0,0 +1,37 @@
+import { RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { CancelSelectionReasons } from '../../../typings/planner';
+import { default as EventDispatcher } from './event-dispatcher';
+
+export declare const enum SELECTION_MODE {
+    STANDARD = "standard",
+    MULTISELECT = "multiselect"
+}
+export declare const enum SELECTION_EVENT {
+    SELECT_COMPONENT = 0,
+    DESELECT_COMPONENT = 1
+}
+export declare class SelectionHandlerEvent {
+    component: RoomleComponent;
+    resetCamera: boolean;
+    consecutive: boolean;
+    reason: CancelSelectionReasons;
+    constructor(data: {
+        component?: RoomleComponent;
+        resetCamera?: boolean;
+        consecutive?: boolean;
+        reason?: CancelSelectionReasons;
+    });
+}
+export default class SelectionHandler extends EventDispatcher<SelectionHandlerEvent> {
+    private _selectionMode;
+    protected _selectedComponents: Map<number, RoomleComponent>;
+    check(component: RoomleComponent): void;
+    cancelSelection(reason: CancelSelectionReasons): boolean;
+    private _checkStandard;
+    private _checkMulti;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    getSelectionMode(): SELECTION_MODE;
+    hasSelection(): boolean;
+    getSelectedRuntimeComponentIds(): number[];
+    isSelected(component: RoomleComponent): boolean;
+}

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

@@ -0,0 +1,4 @@
+import { RoomleSortable } from '../../../typings/rapi-types';
+
+export declare const sortBySort: (a: RoomleSortable, b: RoomleSortable) => number;
+export declare const sortByString: (aLabel: string, bLabel: string) => number;

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

@@ -0,0 +1 @@
+export declare function waitForTween(): Promise<unknown>;

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

@@ -0,0 +1 @@
+export default function (test: (reject: (error: Error) => void) => void): Promise<unknown>;

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/fetch-helper.d.ts

@@ -0,0 +1,8 @@
+import { RapiJsonBox } from '../../../../typings/rapi-types';
+
+export default class FetchHelper {
+    static setup(): void;
+    static setResponseJson(json: RapiJsonBox): void;
+    static getRequestedUrls(): string[];
+    static teardown(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/globals-helper.d.ts

@@ -0,0 +1,4 @@
+export default class GlobalsHelper {
+    static setup(): void;
+    static teardown(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/image-diff.d.ts

@@ -0,0 +1,11 @@
+import { Configurator } from '../../configurator';
+import { Base64String } from '../../../../typings/rapi-types';
+
+export interface ImageDiffResult {
+    getImageDataUrl: () => Base64String;
+    rawMisMatchPercentage: number;
+}
+export default class ImageDiff {
+    private static _compare;
+    static compare(app: Configurator, image1Url: string, image2Url: string): Promise<ImageDiffResult>;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/mock-data/materials.d.ts

@@ -0,0 +1,12 @@
+import { RapiJsonBox, RapiMaterial } from '../../../../../typings/rapi-types';
+
+interface RapiMaterialBox extends RapiJsonBox {
+    materials: RapiMaterial[];
+}
+export default class MaterialsFactory {
+    static create(amount: number): RapiJsonBox;
+    static createByIds(ids: string[] | number[]): RapiMaterialBox;
+    static idsToUrl(ids: string[] | number[]): string;
+    static generateMaxIds(): any[];
+}
+export {};

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/mock-data/partlists.d.ts

@@ -0,0 +1,2 @@
+export declare const PARTLIST_USM_DRAG_TEST: any;
+export declare const PARTLIST_USM_PREVIEWS: any;

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/preview-helper.d.ts

@@ -0,0 +1,4 @@
+export default class PreviewHelper {
+    static setup(): HTMLDivElement;
+    static teardown(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/ui-mock.d.ts

@@ -0,0 +1,18 @@
+import { UiPossibleChild, KernelParameter } from '../../../../typings/kernel';
+import { RapiId } from '../../../../typings/rapi-types';
+
+export default class UIMock {
+    private _element;
+    private _possibleChildren;
+    private _parameters;
+    private _possibleChildrenWaiter;
+    private _parametersWaiter;
+    constructor(element: HTMLElement);
+    private _onUpdateParameters;
+    private _onUpdatePossibleChildren;
+    initAndLoadId(id: RapiId): Promise<void>;
+    possibleChildrenUpdate(): Promise<void>;
+    parametersUpdate(): Promise<void>;
+    getParameterByKey(id: string): KernelParameter;
+    getPossibleChild(id: RapiId): UiPossibleChild;
+}

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

@@ -0,0 +1,4 @@
+export declare function cleanRapiUrl(url: string): string;
+export declare const spyOnModuleMethod: (jest: any, module: any, methodName: string) => any;
+export declare const makeModuleSpyable: (jest: any, module: any) => any;
+export declare const removePrivateProperties: (array: any[]) => any[];

package/packages/web-sdk/packages/configurator-core/src/utils/test-helpers/webgl-mock.d.ts

@@ -0,0 +1,10 @@
+export default class WebGlMock {
+    requestDeleteComponentCalled: boolean;
+    context: {
+        planObjectBounds: {};
+        rootComponentId: number;
+    };
+    cancelSelection(): void;
+    requestDeleteComponent(): void;
+    onRemovePreviews(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/utils/text-with-background.d.ts

@@ -0,0 +1,24 @@
+import { Object3D, Vector3 } from 'three';
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
+
+export default class TextWithBackground extends Object3D {
+    private _cacheHolder;
+    private _position;
+    private _label;
+    private _parameters;
+    private _text;
+    private _textGeometry;
+    private _plane;
+    topDown: boolean;
+    private _planeMaterial;
+    private _textMaterial;
+    private _cameraPosition;
+    constructor(font: Font);
+    private _initMaterials;
+    private _init;
+    update(position: Vector3, label: string, cameraPosition: Vector3): void;
+    private _update;
+    private _updateText;
+    private _getXSign;
+    dispose(): void;
+}

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

@@ -0,0 +1,24 @@
+import { default as EventDispatcher } from './event-dispatcher';
+import { CanvasOffset } from '../../../common-core/src/common-interfaces';
+import { PerspectiveCamera, Vector3 } from 'three';
+
+export type UIIntersection = 'left' | 'top' | 'right' | 'bottom';
+export type UIIntersections = UIIntersection[];
+export declare const enum UI_INTERSECTION_EVENT {
+    CHANGE = 0
+}
+export default class UiIntersectionHelper extends EventDispatcher<UIIntersections> {
+    private _uiIntersectionMask;
+    private _camera;
+    private _boundingBox;
+    private _clientWidth;
+    private _clientHeight;
+    private _boxVertices;
+    private _offset;
+    floorEnvironment: boolean;
+    constructor(camera: PerspectiveCamera);
+    updateToBounds(bounds: Vector3, clientWidth: number, clientHeight: number): void;
+    set canvasOffset(offset: CanvasOffset);
+    calculateUIIntersection(): void;
+    private _checkPaddings;
+}

package/packages/web-sdk/packages/configurator-core/src/webgl/banana-for-scale.d.ts

@@ -0,0 +1,14 @@
+import { ScenePluginDefaultImplementation } from './plugin-system';
+import { Box3, Scene } from 'three';
+
+export default class BananaForScale extends ScenePluginDefaultImplementation {
+    private _scene;
+    private _bounds;
+    private _banana;
+    private _staticItemLoader;
+    setScene(scene: Scene): void;
+    updateBounds(bounds: Box3): void;
+    clearScene(scene: Scene, uiScene: Scene): void;
+    addToScene(): void;
+    removeFromScene(): void;
+}

package/packages/web-sdk/packages/configurator-core/src/webgl/configurator-mesh-generator.d.ts

@@ -0,0 +1,12 @@
+import { default as MeshGenerator } from '../../../common-core/src/webgl/mesh-generator';
+import { KernelEnum } from '../../../typings/kernel';
+import { RapiMaterial } from '../../../typings/rapi-types';
+import { Material, Mesh, MeshPhysicalMaterial } from 'three';
+
+export default class ConfiguratorMeshGenerator extends MeshGenerator {
+    constructor(creator: string);
+    generateMesh(runtimeComponentId: number, geometryId: string, materialId: string, vertices: Float32Array, indices: Int32Array, uvCoords: Float32Array, normals: Float32Array, newGeometryInstance?: boolean, materialAttributes?: Record<string, string>): Mesh;
+    setMaterial(mesh: Mesh, materialId: string, _type?: KernelEnum, materialAttributes?: Record<string, string>): Promise<void>;
+    loadMaterial(materialId: string, width?: number, height?: number): Promise<Material>;
+    loadTextures(rapiMaterial: RapiMaterial, material: MeshPhysicalMaterial, width?: number, height?: number): Promise<void>;
+}

package/packages/web-sdk/packages/configurator-core/src/webgl/configurator-scene-event-handler.d.ts

@@ -0,0 +1,94 @@
+import { PreviewComponent, PreviewLineComponent, RoomleComponent } from '../../../common-core/src/webgl/roomle-component-factory';
+import { default as InputManager, INPUT_EVENT_TYPE } from '../../../common-core/src/input/input-manager';
+import { SELECTION_MODE } from '../utils/selection-handler';
+import { default as SceneEventHandler } from '../../../common-core/src/webgl/scene-event-handler';
+import { RAYCAST_PRIORITY } from '../utils/raycast-helper';
+import { Object3D, PerspectiveCamera, Scene, Vector3, Camera } from 'three';
+import { Enumify } from '../../../common-core/src/types';
+import { CancelSelectionReasons } from '../../../typings/planner';
+
+export declare const enum SCENE_EVENT {
+    INTERACTION = 0,
+    HOVER_ON = 1,
+    HOVER_OFF = 2,
+    CLICK_OUTSIDE = 3,
+    DRAG_START = 4,
+    DRAG_MOVE = 5,
+    DRAG_END = 6,
+    CLICK_PREVIEW = 7,
+    SELECT_COMPONENT = 8,
+    DESELECT_COMPONENT = 9
+}
+export declare class SceneEventInfo {
+    component: RoomleComponent;
+    preview: PreviewComponent;
+    resetCamera: boolean;
+    consecutive: boolean;
+    type: INPUT_EVENT_TYPE;
+    forceRender: boolean;
+    reason: CancelSelectionReasons;
+    constructor(data: {
+        component?: RoomleComponent;
+        preview?: PreviewComponent;
+        resetCamera?: boolean;
+        consecutive?: boolean;
+        type?: INPUT_EVENT_TYPE;
+        forceRender?: boolean;
+        reason?: CancelSelectionReasons;
+    });
+}
+export interface ComponentEventInfo {
+    hasListener: boolean;
+    priority: Enumify<typeof RAYCAST_PRIORITY>;
+    roomleId: number;
+}
+export default class ConfiguratorSceneEventHandler extends SceneEventHandler<SceneEventInfo> {
+    _creator_: string;
+    private _selectionHandler;
+    private _configuratorUiCallbacks;
+    private _cameraMoving;
+    private _hoveredComponent;
+    private _hoveredPreview;
+    private _draggedComponent;
+    private _previewLineIntersection;
+    private _dragStartPosition;
+    private _dragStartRotation;
+    constructor(creator: string, scene: Scene, camera: PerspectiveCamera, inputManager: InputManager);
+    disable(): void;
+    enable(): void;
+    private _addInputListeners;
+    addComponentHandlers(component: RoomleComponent): void;
+    addComponentDragInHandler(component: RoomleComponent): void;
+    private _addComponentHandlers;
+    addPreviewHandlers(component: PreviewComponent): void;
+    addPreviewLineHandlers(component: PreviewLineComponent): void;
+    private _clickPreview;
+    private _clickPreviewLine;
+    clickComponent(component: RoomleComponent, triggerClickCallback?: boolean): void;
+    private _clickOutside;
+    private _hoverOn;
+    private _hoverOff;
+    private _hoverOnPreview;
+    private _hoverOffPreview;
+    private _hoverOnPreviewLine;
+    private _hoverMovePreviewLine;
+    private _updatePositionForPreviewLine;
+    private _hoverOffPreviewLine;
+    private _setDragComponentShadow;
+    private _dragStart;
+    private _drag;
+    private _dragEnd;
+    protected _interaction(forceRender?: boolean): void;
+    hasSelection(): boolean;
+    update(bounds: Vector3, rootComponentPosition: Vector3, backgroundScene: Scene): void;
+    isDragIn(): boolean;
+    isDragging(): boolean;
+    setRootComponentId(rootComponentId: number): void;
+    cancelSelection(reason: CancelSelectionReasons): boolean;
+    setSelectionMode(mode: SELECTION_MODE): void;
+    getSelectionMode(): SELECTION_MODE;
+    getSelectedRuntimeComponentIds(): number[];
+    setCameraMoving(cameraMoving: boolean): void;
+    setCamera(camera: Camera): void;
+    setObject(object: Object3D): void;
+}