@roomle/embedding-lib 5.25.0-alpha.5 → 5.25.0-alpha.7

package/docs/md/web/embedding/CHANGELOG.md

@@ -1,14 +1,8 @@
-## [5.25.0-alpha.5](https://github.com/roomle-dev/roomle-ui/compare/embedding-lib-v5.25.0-alpha.4...embedding-lib-v5.25.0-alpha.5) (2025-08-06)
+## [5.25.0-alpha.7](https://github.com/roomle-dev/roomle-ui/compare/embedding-lib-v5.25.0-alpha.6...embedding-lib-v5.25.0-alpha.7) (2025-08-06)
 
 
 ### Features
 
-* show custom component dimensions when click on measurements icon ([134a2df](https://github.com/roomle-dev/roomle-ui/commit/134a2dfda3186fa3a6c07d5d65d52ff6701511f3))
-
-
-### Bug Fixes
-
-* another dev dep ([89a67e4](https://github.com/roomle-dev/roomle-ui/commit/89a67e41fd02ae7f83eff2c06be84af3980fb6b8))
-* development builds loading envmaps ([3983d81](https://github.com/roomle-dev/roomle-ui/commit/3983d81ef3466816ff8310c0d759583537e068b6))
-* message handler return ([1d6afc7](https://github.com/roomle-dev/roomle-ui/commit/1d6afc747416de5840b22216831c443cee473954))
-* sw paths ([c2d7ffd](https://github.com/roomle-dev/roomle-ui/commit/c2d7ffda8b8d539d25c592681c63c43aee4fd27d))
+* integrate check attributes conflict solving into emulator ([40017b0](https://github.com/roomle-dev/roomle-ui/commit/40017b0a83ef9cf23a9a59cc76fa31b2bd249717))
+* update pos data model ([e612333](https://github.com/roomle-dev/roomle-ui/commit/e6123333b262ce72339f3059cde95128449bc849))
+* updateAttribute API from OC ([3b4af28](https://github.com/roomle-dev/roomle-ui/commit/3b4af289a58a1669ca66e66649876d28e1bdc421))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roomle/embedding-lib",
-  "version": "5.25.0-alpha.5",
+  "version": "5.25.0-alpha.7",
   "description": "This is a small library which can be used to communicate with the Roomle Configurator",
   "type": "module",
   "main": "./roomle-embedding-lib.umd.js",

package/packages/embedding-lib/src/examples/homag-intelligence-example.d.ts

@@ -0,0 +1,9 @@
+import { Example } from '../example';
+
+export default class DragInExample implements Example {
+    private _abortController;
+    setupHtml(parent: HTMLElement): Promise<void>;
+    closeExample(): Promise<void>;
+    private start;
+    runExample(): Promise<void>;
+}

package/packages/embedding-lib/src/examples/utils/homag-intelligence/create-catalog.d.ts

@@ -0,0 +1 @@
+export declare const createCatalog: (articleCatalog: HTMLElement, draggable?: boolean) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/default-api-options.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    enableArrangementCorrection: boolean;
+    uiConfiguration: {
+        userRight: string;
+        materialAttributes: string[];
+        attributesVisibleInPlanner: string[];
+        attributeGroupsVisibleInPlanner: any[];
+        showPossibleSubModules: boolean;
+        animatedOpenClose: boolean;
+        showThumbnails: boolean;
+    };
+    materialConfiguration: {
+        defaultMaterial: string;
+        replaceUnmappedMaterialsWithDefault: boolean;
+        materialMapping: {
+            materialName: string;
+            materialId: string;
+        }[];
+    };
+    debugConfiguration: {
+        createDebugGeometry: boolean;
+    };
+    tecConfigInfo: {
+        baseUrlDebug: string;
+        /**
+         * If you do not want to use the proxy provided by Roomle
+         * uncomment the next three lines and comment the line
+         * which has the Roomle proxy URL in it.
+         * BE AWARE: That the example url dfteccdeveu01-app.azurewebsites.net
+         * only works if you requesting from localhost:3100 otherwise you
+         * will have CORS issues
+         */
+        /** comment this line if you do not want to use the Roomle proxy  */
+        baseUrl: string;
+        om: {
+            subscriptionId: string;
+            key: string;
+            importBaseUrl: string;
+        };
+        libraryId: string;
+    };
+};
+export default _default;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/dom-helper.d.ts

@@ -0,0 +1,13 @@
+import { RoomDesignerApiType } from './overlay';
+
+export declare const GROUP_SELECTION_STR = "Group selection";
+export declare const getOverlayDomElement: () => HTMLElement;
+export declare const positionOverlay: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showOverlay: () => void;
+export declare const hideOverlay: () => void;
+export declare const addShadow: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const removeShadow: () => void;
+export declare const currentSelectionType: (selectionPayload: any) => "Group selection" | "Unknown selection type" | "Root module selection" | "Sub module selection";
+export declare const showItemSelectionWarning: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showCustomItemSelectionView: (state: any, roomDesignerApi: RoomDesignerApiType) => Promise<void>;
+export declare const showCustomCatalogView: (roomDesignerApi: RoomDesignerApiType) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/drag-in.d.ts

@@ -0,0 +1,3 @@
+import { RoomDesignerApiType } from './overlay';
+
+export declare const addDragEventListeners: (roomDesignerApi: RoomDesignerApiType, catalogElements: NodeListOf<Element> | Element[], signal: AbortSignal, element?: HTMLElement | null) => void;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/overlay.d.ts

@@ -0,0 +1,2 @@
+export type RoomDesignerApiType = any;
+export declare const initOverlayLogic: (roomDesignerApi: RoomDesignerApiType, posMode: boolean) => Promise<void>;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/state.d.ts

@@ -0,0 +1,14 @@
+export declare const state: {
+    selection: {
+        type: any;
+        payload: any;
+        parameters: any[];
+    };
+    currentContext: string;
+    currentCustomView: any;
+    currentSidebar: any;
+    abortController: AbortController;
+    isBuildingCatalog: any;
+    waitForCatalog: () => Promise<void>;
+};
+export declare const resetSelectionState: () => void;

package/packages/embedding-lib/src/examples/utils/homag-intelligence/util.d.ts

@@ -0,0 +1,19 @@
+export declare const fetchJSONData: (url: string) => Promise<any>;
+export declare const fetchDataWithAuthorization: (url: string, type: string, property: string) => Promise<Response>;
+export declare const logMessage: (message: string, ...args: (string | null)[]) => void;
+export declare const logApiCall: (message: string) => void;
+export declare const logApiCallback: (message: string, ...args: (string | null)[]) => void;
+export declare const logLink: (message: string, linkUrl: string) => void;
+export declare class RenderQueue {
+    reRenders: number;
+    queue: Array<{
+        renderFn: any;
+        resolve: any;
+        reject: any;
+    }>;
+    isProcessing: boolean;
+    constructor();
+    enqueue(renderFn: any): Promise<unknown>;
+    processQueue(): Promise<void>;
+}
+export declare const getQueryParam: (key: string, url?: string) => string;

package/packages/web-sdk/packages/common-core/src/main.d.ts

@@ -86,7 +86,7 @@ export default abstract class Main implements LifeCycleCallbacks {
     protected abstract setupDependencies(): void;
     protected abstract cleanUpGlobals(): void;
     protected abstract cleanUpDependencies(): void;
-    protected abstract bootFinished(): void;
+    protected abstract bootFinished(): Promise<void>;
     protected abstract getContextName(): string;
     abstract getApi(): ExternalEmbeddable;
     constructor(creator?: string);
@@ -94,7 +94,7 @@ export default abstract class Main implements LifeCycleCallbacks {
     private _setupCommonDependencies;
     private _cleanUpCommonGlobals;
     private _cleanUpCommonDependencies;
-    boot(settings?: object): void;
+    boot(settings?: object): Promise<void>;
     protected lookup<T>(specifier: string, context?: string): T;
     teardown(): void;
     pause(): void;

package/packages/web-sdk/packages/common-core/src/utils/init-data.d.ts

@@ -9,6 +9,7 @@ import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/sha
 import { RapiId } from '../../../typings/rapi-types';
 import { CanvasOffset } from '../common-interfaces';
 import { ExternalObjectApiConfiguration } from '../../../planner-core/src/external-object-api';
+import { HomagIntelligenceInitData } from '../../../homag-intelligence/src/loader';
 
 export declare const DEFAULT_ENV_MAP_INTENSITY = 1.5;
 export declare const DEFAULT_ENV_MAP_ROTATION = 0;
@@ -49,6 +50,7 @@ export default class InitData implements Context, Omit<InitDataDefinition, 'colo
     customShading?: CustomShadingParameters;
     customShadingMoc?: CustomShadingParameters;
     restrictionLevel?: number;
+    hi?: HomagIntelligenceInitData;
     offlineSync?: string;
     highlighting?: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
     initialFloorMaterial?: string;

package/packages/web-sdk/packages/common-core/src/utils/shims.d.ts

@@ -6,6 +6,7 @@ import { Enumify } from '../types';
 import { DefaultEnvironmentSceneType } from '../webgl/renderer/environment-scene';
 import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/shading-settings';
 import { Color } from 'three';
+import { HomagIntelligenceInitData } from '../../../homag-intelligence/src/loader';
 
 export declare const enum WINDOW_EVENT {
     RESIZE = "resize",
@@ -315,6 +316,11 @@ export interface CommonInitData {
      * @description restrictionLevel defines visibility of parameters and possible children
      */
     restrictionLevel?: number;
+    /**
+     * @description Settings for Homag Intelligence
+     * @internal
+     */
+    hi?: HomagIntelligenceInitData;
 }
 export interface ConfiguratorInitData {
     /**

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

@@ -9,6 +9,6 @@ export declare class Configurator extends Main {
     protected cleanUpDependencies(): void;
     protected setupGlobals(appState?: AppState): void;
     getApi(): RoomleConfigurator;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     protected getContextName(): string;
 }

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

@@ -1,4 +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 spyOnModuleMethod: (vi: any, module: any, methodName: string) => any;
+export declare const makeModuleSpyable: (vi: any, module: any) => any;
 export declare const removePrivateProperties: (array: any[]) => any[];

package/packages/web-sdk/packages/glb-viewer-core/src/glb-viewer.d.ts

@@ -7,7 +7,7 @@ export declare class GlbViewer extends Main {
     protected setupDependencies(): void;
     protected cleanUpGlobals(): void;
     protected cleanUpDependencies(): void;
-    protected bootFinished(): void;
+    protected bootFinished(): Promise<void>;
     getApi(): RoomleGLBViewer;
     protected getContextName(): string;
 }

package/packages/web-sdk/packages/homag-intelligence/src/api.d.ts

@@ -0,0 +1,22 @@
+import { RoomDesignerRequests } from './emulator';
+import { MasterData, PosGroup } from './model/oc-scripts-domain.model';
+import { RoomlePlannerType } from '../../typings/external-objects';
+
+export declare class RoomDesignerApi implements RoomDesignerRequests {
+    private _roomlePlanner;
+    constructor(roomlePlanner: RoomlePlannerType);
+    loadMasterData(masterData: MasterData): void;
+    loadPosGroups(posDataJson: PosGroup | PosGroup[], findFreeSpaceInPlan: boolean, verifyArrangement: boolean, mergedGroups?: string[]): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectRoot(rootModuleId: string): Promise<void>;
+    selectModule(rootModuleId: string, subModuleId: string): Promise<void>;
+    openCloseGroup(groupOrRootModuleId: string, subModuleId: string | null, open: boolean, animate: boolean): Promise<void>;
+    deleteGroup(groupId: string, wasMerged?: boolean): Promise<void>;
+    deleteRootModule(rootModuleId: string): Promise<void>;
+    getPosDataOfAllGroups(): Promise<PosGroup[]>;
+    generatePlanSnapshot(): Promise<void>;
+    saveExternalObjectSnapshot(): Promise<import('../../typings/rapi-types').RapiPlanSnapshotGetDataWith3dUrls>;
+    saveCurrentPlanSnapshot(): Promise<import('../../typings/rapi-types').RapiPlanSnapshotGetData>;
+    renderPosDataImage(posDataJson: object): Promise<void>;
+    downloadGlb(): Promise<void>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/callbacks.d.ts

@@ -0,0 +1,37 @@
+import { GlueLogic } from './emulator';
+import { default as RoomlePlanner } from '../../planner-core/src/roomle-planner';
+
+export interface ExternalObjectSegment {
+    cmd: string;
+    x: number;
+    y: number;
+    type?: string;
+    angle?: number;
+}
+export interface ExternalObjectContour {
+    level: number;
+    segments: ExternalObjectSegment[];
+}
+export interface ExternalObjectGroupPosition {
+    pos: number[];
+    rotationY?: number;
+    contours?: ExternalObjectContour[];
+}
+export interface ExternalObjectRootModule {
+    moduleId: string;
+    pos: number[];
+    rotationY?: number;
+}
+export interface ExternalObjectGroup {
+    groupId: string;
+    pos: number[];
+    rotationY?: number;
+    rootModules: ExternalObjectRootModule[];
+    contours?: ExternalObjectContour[];
+}
+export interface ExternalModuleInformation {
+    groupId: string;
+    rootModuleId: string;
+    subModuleId: string | null;
+}
+export declare const initCallbacks: (roomlePlanner: RoomlePlanner, gluLogic: GlueLogic) => void;

package/packages/web-sdk/packages/homag-intelligence/src/emulator.d.ts

@@ -0,0 +1,101 @@
+import { ExternalModuleInformation, ExternalObjectGroup, ExternalObjectGroupPosition } from './callbacks';
+import { MasterData, PosModuleAttribute, PosGroup, PosModuleData, PosModuleRootData } from './model/oc-scripts-domain.model';
+
+export interface LibraryData {
+    get masterData(): MasterData | null;
+    get posGroupVersion(): number;
+    calculateGroup(posGroup: PosGroup): PosGroup;
+    getOrderData(posGroup: PosGroup[], roomlePlannerId?: string): PosGroup;
+    getAttributesDropDownValues(module: PosModuleRootData): Promise<any>;
+    solveModuleAttributeConflict(module: PosModuleData, attributeName: string, value: string | number | boolean): PosModuleAttribute[] | undefined;
+}
+export interface RoomDesignerRequests {
+    loadMasterData(masterData: MasterData): void;
+    loadPosGroups(posDataJson: PosGroup | PosGroup[], findFreeSpaceInPlan: boolean, verifyArrangement: boolean, mergedGroups?: string[]): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectRoot(rootModuleId: string): Promise<void>;
+    selectModule(rootModuleId: string, subModuleId: string): Promise<void>;
+    openCloseGroup(groupOrRootModuleId: string, subModuleId: string | null, open: boolean, animate: boolean): Promise<void>;
+    deleteGroup(groupId: string, wasMerged?: boolean): Promise<void>;
+    deleteRootModule(rootModuleId: string): Promise<void>;
+    getPosDataOfAllGroups(): Promise<PosGroup[]>;
+    generatePlanSnapshot(): Promise<void>;
+    saveExternalObjectSnapshot(): Promise<any>;
+    saveCurrentPlanSnapshot(): Promise<any>;
+}
+export interface GlueLogic {
+    mergeGroups(targetGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], idOfTargetRootModule: string): void;
+    deleteRootModule(remainingGroup: ExternalObjectGroup, rootModuleIdToDelete: string, splitOffGroups: ExternalObjectGroup[]): void;
+    splitRootModuleFromGroup(splitGroup: ExternalObjectGroup, newGroupedRootModules: ExternalObjectGroup[]): void;
+    duplicateGroup(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): void;
+    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation[], attributeName: string, value: string): void;
+    arrangeRootModulesOfGroup(changedGroup: ExternalObjectGroup): void;
+    changedGroupPlanningSituation(changedGroup: ExternalObjectGroup): void;
+    deleteGroup(groupId: string): Promise<void>;
+    changedGroup(posDataJson: PosGroup): void;
+    loadedGroup(posDataJson: PosGroup): void;
+    removedGroup(groupId: string): void;
+    openCloseGroup(groupId: string): void;
+    getGroupDataForOrder(roomlePlannerId?: string): Promise<any>;
+    savePlanSnapshot(): Promise<PlanSnapshot>;
+}
+interface PlanSnapshot {
+    id: string;
+    perspectiveImageLink: string;
+    topImageLink: string;
+    room3dLink: string;
+    room3dFullLink: string;
+}
+interface GroupItem {
+    posDataJson: PosGroup;
+    opened: boolean;
+}
+export declare class Emulator implements GlueLogic {
+    _designerRequests: RoomDesignerRequests;
+    _libraryData: LibraryData;
+    _posDataJsonMap: Map<string, any>;
+    _groupMap: Map<string, GroupItem>;
+    _nextPosDataId: number;
+    constructor(designerRequests: RoomDesignerRequests, libraryData: LibraryData);
+    loadPosData(articleCatalogJson: any, libraryId: string): void;
+    newPosDataFromId(id: string): any;
+    deleteGroup(groupId: string): Promise<void>;
+    selectGroup(groupId: string): Promise<void>;
+    selectCheckAttributes(root: PosModuleRootData): Promise<void>;
+    selectRoot(_groupId: any, rootId: string): Promise<void>;
+    deleteRoot(groupId: any, rootId: string): Promise<void>;
+    selectSubModule(groupId: any, rootId: string, moduleId: string): Promise<void>;
+    openCloseGroup(groupId: string): Promise<void>;
+    deleteRootModule(remainingGroup: ExternalObjectGroup, rootModuleIdToDelete: string, splitOffGroups: ExternalObjectGroup[]): void;
+    duplicateGroup(sourceGroupId: string, newGroupPosition: ExternalObjectGroupPosition): Promise<void>;
+    mergeGroups(targetGroup: ExternalObjectGroup, idsOfGroupsMerged: string | string[], idOfTargetRootModule: string): void;
+    private _applyImplicitRelevantAttributes;
+    splitRootModuleFromGroup(splitGroup: ExternalObjectGroup, newGroupedRootModules: ExternalObjectGroup[]): void;
+    arrangeRootModulesOfGroup(changedGroup: ExternalObjectGroup): void;
+    removedGroup(groupId: string): void;
+    changedGroup(posDataJson: PosGroup): void;
+    changedGroupPlanningSituation(changedGroup: ExternalObjectGroup): void;
+    loadedGroup(posDataJson: PosGroup): void;
+    getGroupDataForOrder(roomlePlannerId?: string): Promise<PosGroup>;
+    private _setGroupContour;
+    private _setGroupPosition;
+    private _setRootModulesPosition;
+    private _loadPosData;
+    private _splitOffGroupsFromGroups;
+    private _splitOffRootModulesFromGroup;
+    private _calculateNewGroup;
+    private _calculate;
+    private _calculateAndUpdateGroupMap;
+    private _addNewGroup;
+    private _addGroupToMap;
+    updateAttribute(rootModuleId: string | undefined, moduleId: string, attributeId: string, attributeValue: string | boolean): Promise<void>;
+    modifyAttribute(groupId: string, moduleIdObjects: ExternalModuleInformation[], attributeName: string, value: string): void;
+    _modifyAttributeOfModules(emulatorGroupItem: GroupItem, moduleIds: string[] | string, attributeName: string, value: string | boolean): PosGroup;
+    private _setAttribute;
+    savePlanSnapshot(): Promise<PlanSnapshot>;
+    private _findModule;
+    private _replacesIDs;
+    private _replacesModuleIDs;
+    private _getNextID;
+}
+export {};

package/packages/web-sdk/packages/homag-intelligence/src/homag-intelligence.d.ts

@@ -0,0 +1,28 @@
+import { RmlPlugin } from './rml-plugin';
+import { Emulator } from './emulator';
+import { ApiOptions } from './loader';
+import { MasterData } from './model/oc-scripts-domain.model';
+import { default as RoomlePlanner } from '../../planner-core/src/roomle-planner';
+
+export declare const HOMAG_INTELLIGENCE_ENDPOINT = "https://europe-west3-rml-showcases.cloudfunctions.net/proxy_request?url=";
+export declare class HomagIntelligence extends RmlPlugin {
+    private _roomlePlanner;
+    private _api;
+    private _masterData;
+    private _emulator;
+    private _articles;
+    private _scriptLoaded;
+    private _hiLibraryLoaded;
+    private _orders;
+    constructor();
+    loadHiLibrary(libraryId: string, apiOptions: ApiOptions): Promise<{
+        articles: any;
+        masterData: MasterData;
+        calcScriptLoaded: boolean;
+    }>;
+    init(roomlePlanner: RoomlePlanner, libraryId: string, apiOptions: ApiOptions): Promise<this>;
+    private _loadMasterData;
+    getEmulator(): Emulator;
+    sendToOM(withPrice?: boolean): Promise<void>;
+    fetchPrice(planId?: string): Promise<any>;
+}

package/packages/web-sdk/packages/homag-intelligence/src/loader.d.ts

@@ -0,0 +1,24 @@
+import { MasterData } from './model/oc-scripts-domain.model';
+
+export interface HomagIntelligenceInitData {
+    libraryId: string;
+    serverOptions: ApiOptions;
+}
+export interface OrderManagerOptions {
+    key?: string;
+    importBaseUrl?: string;
+}
+export interface ApiOptions {
+    subscriptionId: string;
+    om?: OrderManagerOptions;
+    endpointUrl?: string;
+    localUrl?: string;
+}
+export declare const fetchDataWithAuthorization: (url: string, type: 'json' | 'text', apiOptions: ApiOptions, debug?: {
+    property: string;
+}) => Promise<Response>;
+export declare const loadHiLibrary: (libraryId: string, apiOptions: ApiOptions) => Promise<{
+    articles: any;
+    masterData: MasterData;
+    calcScriptLoaded: boolean;
+}>;