@roomle/web-sdk 2.91.0-alpha.1 → 2.91.0-alpha.3

package/lib/definitions/packages/common-core/src/services/cache-holder.d.ts

@@ -0,0 +1,11 @@
+import type { RoomleComponent } from '../webgl/roomle-component-factory';
+import type { BufferGeometry, Material } from 'three';
+export default class CacheHolder {
+    private _componentCache;
+    private _geometryCache;
+    private _materialCache;
+    get componentCache(): Map<string, RoomleComponent>;
+    get geometryCache(): Map<string, BufferGeometry>;
+    get materialCache(): Map<string, Material>;
+    clear(): void;
+}

package/lib/definitions/packages/common-core/src/services/common-kernel-access.d.ts

@@ -0,0 +1,131 @@
+import type RapiAccess from '../rapi-access';
+import type ScriptLoader from '../script-loader';
+import type KernelIo from '../kernel-io';
+import type DataSyncer from './data-syncer';
+import type { ArticleNumber, ConfigurationHash, RapiConfiguration, RapiId, RapiPrice } from '../../../typings/rapi-types';
+import type { LifeCycleCallbacks } from '../life-cycle-manager';
+import type { Context } from '../di/context';
+import type { AssetRequest, AssetType, ConfigurationExporter, ConfiguratorKernelClass, KernelComponent, KernelMeshAttributes, KernelMeshBuffer, KernelPart, KernelPartList, KernelPartListPrice, KernelVector3 } from '../../../typings/kernel';
+import type ConfiguratorUiCallbacks from '../../../configurator-core/src/services/configurator-ui-callback';
+import type { GlobalCallback } from './global-callback';
+import type InitData from '../utils/init-data';
+import type UnitFormatter from '../../../configurator-core/src/services/unit-formatter';
+import type ConfiguratorContext from '../webgl/configurator-context';
+import type GlobalInitData from '../utils/global-init-data';
+import type { ConfiguratorKernelCallbackI } from '../configurator-kernel-access';
+export declare const enum KERNEL_TYPE {
+    PLANNER = 0,
+    CONFIGURATOR = 1
+}
+interface SubComponentWaiter {
+    parentId: number;
+    partId: number;
+}
+export declare const USE_DELTA_COMPONENT_UPDATES = true;
+export default abstract class CommonKernelAccess implements LifeCycleCallbacks, Context {
+    _creator_: string;
+    protected _rapiAccess: RapiAccess;
+    protected _scriptLoader: ScriptLoader;
+    protected _kernelIo: KernelIo;
+    protected _dataSyncer: DataSyncer;
+    private _lifeCycleManager;
+    private _requestedItemIds;
+    private _requestedMaterialIds;
+    protected _configuratorUiCallbacks: ConfiguratorUiCallbacks;
+    protected _globalCallback: GlobalCallback;
+    protected _initData: InitData;
+    protected _unitFormatter: UnitFormatter;
+    protected _configuratorContext: ConfiguratorContext;
+    protected _globalInitData: GlobalInitData;
+    protected _lastPartListHash: string;
+    protected _configuratorKernelCallbackListener: Set<ConfiguratorKernelCallbackI>;
+    protected _cachedGroupIds: string[];
+    protected _waitingForGroups: boolean;
+    /**
+     *
+     * !!!WARNING!!!
+     *
+     * @todo check if this can become a problem if we tell
+     *       the minifier to mangle properties stargin with _
+     *       see the discussion at https://gitlab.com/roomle/roomle-threejs/merge_requests/401#note_143575143
+     *
+     * not sure if we can prefix protected methods with _
+     * the leading _ was done for minification purpose, because
+     * JS minifier do not know the visibility of TypeScript
+     * therefore they do not mangle class properties because they
+     * do not know if a property is public or private, but you can
+     * tell the minifier that everything with a certain prefix is
+     * private and then they mangle these class properties. I'm not
+     * sure if minification breaks the app if property names of the
+     * abstract class are mangled! We have to check this! Currently
+     * we us the minifier called terser
+     *
+     * !!!WARNING!!!
+     *
+     */
+    protected _kernelType: KERNEL_TYPE;
+    protected _kernelInstance: ConfiguratorKernelClass;
+    protected _configurationExporter: ConfigurationExporter;
+    protected _kernelContainer: any;
+    protected _subComponentsWaiters: Map<RapiId, SubComponentWaiter[]>;
+    protected _shouldWait: boolean;
+    protected _kernelPath: string;
+    protected _useWASM: boolean;
+    protected _utilityToLongArray(longArray: number[]): any;
+    protected abstract onLoadComponentError(error: Error, id: RapiId): void;
+    constructor(creator: string);
+    protected init(kernelType: KERNEL_TYPE): void;
+    protected _initKernel(): void;
+    get kernelContainer(): any;
+    get kernelInstance(): ConfiguratorKernelClass;
+    get configurationExporter(): ConfigurationExporter;
+    private _setupKernelPaths;
+    private _setupEmsModule;
+    private _passSubComponentsToKernel;
+    private _fetchSubComponents;
+    private _flushSubComponentsWaiters;
+    protected isReady(): void;
+    protected addDebugInfo(): void;
+    getConfigurationData(planObjectId: number): Promise<RapiConfiguration>;
+    requestAssets(requestedAssets: AssetRequest[]): void;
+    loadComponent(componentIds: string[]): void;
+    loadItemConfigurations(itemIds: string[]): Promise<void>;
+    requestDeleteComponent(componentId: number): void;
+    dockComponentWithPosition(parentId: number, parentDockId: number, childId: number, childDockId: number, position: KernelVector3): void;
+    Editor3dAddMesh(runtimeComponentId: number, meshId: number, geometryName: string, environmentGeometry: boolean, meshAttributes: KernelMeshAttributes, meshBuffer: KernelMeshBuffer): void;
+    Editor3ChangedMesh(runtimeComponentId: number, meshId: number, geometryName: string, meshAttributes: KernelMeshAttributes): void;
+    Editor3dRemoveMesh(runtimeComponentId: number, meshId: number): void;
+    Editor3dBeginConstruction(id: number, isDeltaUpdate: boolean): void;
+    Editor3dEndConstruction(id: number): void;
+    Editor3dComponentCreated(id: number, position: KernelVector3, eulerAngles: KernelVector3, isRootComponent: boolean, parentObjectRuntimeId: number): void;
+    Editor3dComponentDocked(componentId: number, isRootComponent: boolean, parentId: number, componentPosition: KernelVector3, componentRotation: KernelVector3): void;
+    Editor3dGeometryReady(id: number): void;
+    Editor3dGeometryNotReady(id: number): void;
+    componentDeleted(componentId: number): void;
+    componentMetaUpdated(componentId: number): void;
+    sceneCleared(): void;
+    requestMaterialsInGroup(groupIds: string[]): void;
+    requestPlanComponentConstruction(id: number, useDeltaUpdates?: boolean): void;
+    addConfiguratorListener(listener: ConfiguratorKernelCallbackI): void;
+    removeConfiguratorListener(listener: ConfiguratorKernelCallbackI): void;
+    cleanUpCallbacks(): void;
+    requestMaterialProperties(materialIds: RapiId[]): Promise<void>;
+    protected registerCallbacks(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+    protected _handleCortoMesh(buffer: ArrayBuffer, meshId: string, quality: number): void;
+    private _requestAssetByExternalUrl;
+    protected _handleInvalidAsset(assetType: AssetType, idOrUrl: string, quality: number): void;
+    calcPartsPriceSum(partList: KernelPartList): Promise<KernelPartListPrice>;
+    protected _calcPrice(partList?: KernelPartList): Promise<KernelPartListPrice>;
+    addUiDataAndPriceToPartList(partList: KernelPartList, hash: string): Promise<KernelPartList>;
+    addLabelToKernelComponent(kernelComponent: KernelComponent): void;
+    addUiDataToPartList(partList: KernelPart[], hash: string): KernelPart[];
+    requestExternalMesh(_requestedMeshes: Array<{
+        meshId: string;
+        quality: number;
+    }>): void;
+    requestPartListAndUpdatePricesOfParts(hash?: ConfigurationHash, _prices?: Map<ArticleNumber, RapiPrice>): Promise<void>;
+}
+export {};

package/lib/definitions/packages/common-core/src/services/data-syncer.d.ts

@@ -0,0 +1,41 @@
+import type { CommunicationInterfaceCallback } from '../../../workers/src/communication-interface';
+import { WORKER_MESSAGE } from '../../../workers/src/communication-interface';
+import type { RapiId, AssetUrl } from '../../../typings/rapi-types';
+import type { Context } from '../di/context';
+export default class DataSyncer implements Context, CommunicationInterfaceCallback {
+    _creator_: string;
+    private _rapiAccess;
+    private _singlePromiseFactory;
+    private _errorHandler;
+    private _configuratorUiCallbacks;
+    private _initData;
+    private _worker;
+    private _mainThreadToWorker;
+    private _bootCallbacks;
+    private _isStarted;
+    private _isStarting;
+    private _alwaysUseCache;
+    constructor(creator: string);
+    start(catalogId: RapiId): Promise<void>;
+    syncCatalog(catalogId: RapiId): Promise<void>;
+    syncFloorTag(tagId: RapiId): Promise<any>;
+    syncTypeChangeTag(tagId: RapiId): Promise<any>;
+    private _syncFloorTag;
+    _syncTypeChangeTag(tagId: RapiId): Promise<any>;
+    getIsCatalogSynced(catalogId: RapiId): boolean;
+    private _startWorker;
+    onCommand(command: WORKER_MESSAGE, conversationId: number, data: any): void;
+    private _handleCatalog;
+    private _handleTags;
+    private _handleExternalMeshes;
+    private _handleItemsAndAdditionalContents;
+    private _handleMaterialsAndTextures;
+    private _handleContentWithAssets;
+    private _fetchAssets;
+    private _preCacheAsset;
+    private _assetUrlToBase64;
+    private _softReject;
+    requestAsset(url: string, urlAsFallback?: boolean): AssetUrl;
+    setAlwaysUseCache(alwaysUseCache: boolean): void;
+    preFillAssetCache(key: string, url: string): void;
+}

package/lib/definitions/packages/common-core/src/services/global-callback.d.ts

@@ -0,0 +1,35 @@
+import type { Nullable } from '../../../typings/helper';
+import type { RapiJsonBox } from '../../../typings/rapi-types';
+import type { KernelMessageMetaInfo, KernelMessageType } from '../kernel-io';
+import type { ExternalResponseValidator, FetchOptions, RAPI_PATHS } from '../rapi-access';
+import { UiCallback } from '../utils/ui-callback';
+export declare class GlobalCallback extends UiCallback {
+    /**
+     * is called when a network request is made
+     * @param url string the fetched url
+     * @param data RequestInit what is used to init the request
+     * @param options object what additional options do we use
+     */
+    onNetworkRequest: (_url: string, _data: RequestInit, _options: FetchOptions) => void;
+    /**
+     * is called when the Kernel sends us some message
+     * @param _type KernelMessageType can either be exception, error or warning
+     * @param _message string the message from the Kernel
+     * @param _meta KernelMessageMetaInfo optional, adds more information for debugging
+     */
+    onKernelMsg: (_type: KernelMessageType, _message: string, _meta?: KernelMessageMetaInfo) => void;
+    onCheckExternalCache: (_url: string, _requestData: RequestInit) => Promise<any>;
+    onValidateNetworkResponse: ExternalResponseValidator;
+    /**
+     *
+     * @param _url URL of the request
+     * @param _rapiPath the RAPI_PATHS enum
+     * @param _json the JSON response
+     * @returns void
+     */
+    onApiJsonReceived: (_url: string, _rapiPath: RAPI_PATHS, _json: any) => Promise<Nullable<RapiJsonBox> | undefined>;
+    /**
+     * is called the scene is ready for rendering it as an image
+     */
+    onReadyForRender: () => void;
+}

package/lib/definitions/packages/common-core/src/services/hdr-environment-loader.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '../di/context';
+import type { Texture, WebGLRenderer } from 'three';
+export interface EnvironmentMapResult {
+    url: string;
+    environmentMap: Texture;
+}
+export default class HdrEnvironmentLoader implements Context {
+    _creator_: string;
+    private _environmentMap;
+    private _envChangedCallback;
+    private _exrLoader;
+    private _rgbeLoader;
+    constructor(creator: string);
+    loadUrl(renderer: WebGLRenderer, url: string): Promise<EnvironmentMapResult>;
+    private _loadExr;
+    private _loadRgbe;
+    registerEnvironmentChangedCallback(callBack: (maps: EnvironmentMapResult) => void): void;
+}

package/lib/definitions/packages/common-core/src/services/idb-manager.d.ts

@@ -0,0 +1,19 @@
+import type { SavedIdbData, UseIdbStore } from '../types';
+import type { Context } from '../di/context';
+export default class IdbManager implements Context {
+    _creator_: string;
+    private _initData;
+    readonly configStore: UseIdbStore;
+    constructor(creator: string);
+    private get allStores();
+    private _getValue;
+    private _setValue;
+    private _getEntries;
+    deleteValue(key: IDBValidKey, objStore: UseIdbStore): Promise<void>;
+    private _createStore;
+    getKey(...args: string[]): string;
+    setValue<T>(key: string, value: T, store: UseIdbStore): Promise<void>;
+    getValue<T>(key: IDBValidKey, store: UseIdbStore): Promise<SavedIdbData<T> | undefined>;
+    clearStore(objStore: UseIdbStore): Promise<void>;
+    pruneOldEntries(): Promise<void>;
+}

package/lib/definitions/packages/common-core/src/services/memory-manager.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigurationString } from '../../../typings/rapi-types';
+export default class MemoryManager {
+    private _configurationStringSet;
+    private _singleLoadCounter;
+    constructor();
+    loadingConfigurationString(): void;
+    loadingConfiguration(configurationId: ConfigurationString): void;
+    shouldHardReset(): boolean;
+    executedHardReset(): void;
+}

package/lib/definitions/packages/common-core/src/static-files/environment-maps.d.ts

@@ -0,0 +1,7 @@
+export { default as ENV_MAP_FILE_NAME } from '../../public/textures/env/roomle.envmap?url';
+export { default as ENV_32_MAP_FILE_NAME } from '../../public/textures/env/roomle32.envmap?url';
+export { default as ENV_64_MAP_FILE_NAME } from '../../public/textures/env/roomle64.envmap?url';
+export { default as ENV_HDR_256_FILE_NAME } from '../../public/textures/env/default_256.exr?url';
+export { default as ENV_HDR_1K_FILE_NAME } from '../../public/textures/env/default_1k.exr?url';
+export { default as ENV_LEGACY } from '../../public/textures/env/legacy_env.exr?url';
+export { default as PAPER_BACKGROUND_FILE_NAME } from '../../public/textures/paper_background.png?url';

package/lib/definitions/packages/common-core/src/static-files/libs.d.ts

@@ -0,0 +1 @@
+export { default as JS_ZIP_FILE_NAME } from 'jszip/dist/jszip.min.js?url';

package/lib/definitions/packages/common-core/src/static-files/light-settings.d.ts

@@ -0,0 +1,6 @@
+export { default as LIGHT_SETTINGS_BAKED_FILE_NAME } from '../../public/predefined_lightsettings/baked.json?url';
+export { default as LIGHT_SETTINGS_CAMERA_FILE_NAME } from '../../public/predefined_lightsettings/camera.json?url';
+export { default as LIGHT_SETTINGS_EQUAL_FILE_NAME } from '../../public/predefined_lightsettings/equal.json?url';
+export { default as LIGHT_SETTINGS_SHELF_FRONT_FILE_NAME } from '../../public/predefined_lightsettings/shelf_front.json?url';
+export { default as LIGHT_SETTINGS_SHELF_FILE_NAME } from '../../public/predefined_lightsettings/shelf.json?url';
+export { default as LIGHT_SETTINGS_SOFA_FILE_NAME } from '../../public/predefined_lightsettings/sofa.json?url';

package/lib/definitions/packages/common-core/src/static-files/roomle-core.d.ts

@@ -0,0 +1,7 @@
+export { default as CONFIGURATOR_WASM_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/ConfiguratorKernel.wasm?url';
+export { default as CONFIGURATOR_LOADER_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/ConfiguratorKernel.js?url';
+export { default as PLANNER_WASM_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/RoomleCore.wasm?url';
+export { default as PLANNER_LOADER_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/RoomleCore.js?url';
+export { default as TOOLS_CORE_WASM_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/RoomleToolsCore.wasm?url';
+export { default as TOOLS_CORE_LOADER_MODERN_FILE_NAME } from 'roomle-core-hsc/wasm_modern/RoomleToolsCore.js?url';
+export { default as TWEEN_FILE_NAME } from '../../../three-build/src/Tween.js?url';

package/lib/definitions/packages/common-core/src/static-files/three.d.ts

@@ -0,0 +1,5 @@
+export declare const DRACO_LIB_FILES: {
+    'draco_wasm_wrapper.js': any;
+    'draco_decoder.wasm': any;
+    'draco_decoder.js': any;
+};

package/lib/definitions/packages/common-core/src/types.d.ts

@@ -0,0 +1,8 @@
+export type Enumify<T> = T[keyof T];
+export type UseIdbStore = <T>(txMode: IDBTransactionMode, callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>;
+export interface SavedIdbData<T> {
+    id: string;
+    data: T;
+    lastModified: string;
+    referrer: string;
+}

package/lib/definitions/packages/common-core/src/utils/app-context.d.ts

@@ -0,0 +1,14 @@
+export interface AppState {
+    locale?: string;
+    kernelInstance?: any;
+    kernelContainer?: any;
+    planObjectId?: number;
+}
+export default class AppContext {
+    static useHDGeometry: boolean;
+    static kernelInstance: any;
+    static kernelContainer: any;
+    static planObjectId: number;
+    static init(appState?: AppState): void;
+    static cleanUp(): void;
+}

package/lib/definitions/packages/common-core/src/utils/benchmark.d.ts

@@ -0,0 +1,24 @@
+export declare const enum MARKS {
+    KERNEL_IS_READY = "kernel_is_ready",
+    KERNEL_CREATE = "kernel_create_instance",
+    KERNEL_COMPILE_INSTANCE = "kernel_compile_instance",
+    UI_LOAD_CONFIGURATION = "ui_load_configuration",
+    KERNEL_STREAM_COMPILE_INSTANCE = "kernel_stream_compile",
+    KERNEL_LEGACY_COMPILE_INSTANCE = "kernel_legacy_compile",
+    RAPI_PRELOADS = "rapi_preloads"
+}
+export declare const enum UI_TRACKING {
+    KERNEL_IS_READY = "KernelIsReady",
+    RAPI_PRELOADS = "RapiPreloads"
+}
+export declare const enum TRACKING_CATEGORIES {
+    TIMING = "Timing"
+}
+export default class Benchmark {
+    static start(name: string | MARKS): string;
+    static addMeta(name: string | MARKS, data: object): void;
+    static getMeta(name: string | MARKS): object;
+    static end(_name: string | MARKS): void;
+    static getMeasure(_name: string | MARKS): PerformanceMeasure[];
+    static showBenchmarks(filter?: string): void;
+}

package/lib/definitions/packages/common-core/src/utils/browser-helper.d.ts

@@ -0,0 +1,6 @@
+export declare const BROWSER_LANGUAGE_PROPERTY_KEYS_KNOWN: string[];
+export declare const getLanguage: (lang?: string) => any;
+export declare const isIosDevice: () => boolean;
+export declare const isFirefox: () => boolean;
+export declare const isSafari: boolean;
+export declare const isAndroidDevice: () => boolean;

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

@@ -0,0 +1,111 @@
+import '../../../typings/global-definitions';
+import type { RapiId, RapiItem, RapiJson, RapiMaterial, RapiTexture } from '../../../typings/rapi-types';
+import type { KernelFloorMaterial, KernelWallMaterial } from '../../../typings/planner';
+import type { BatchPaintMaterial } from '../../../planner-core/src/roomle-planner';
+import { Color } from 'three';
+import type { CameraParameter } from '../cameracontrol/camera-control';
+export declare const enum CURSOR_STYLE {
+    HOVER = "pointer",
+    DEFAULT = "default",
+    MOVE = "move",
+    DRAGGING = "grabbing",
+    ROTATE = "ew-resize",
+    NODE_HOVER = "crosshair",
+    DRAW = "url('https://res.cloudinary.com/roomle/image/upload/v1664957371/pencil_j5vkhm.svg') 3 20, auto",
+    DRAW_FALLBACK = "url('https://res.cloudinary.com/roomle/image/upload/v1664957371/pencil_j5vkhm.svg') 0 15, auto"
+}
+/**
+ * Colors can be set as hex value, eg 0x00ff00 or as official HTML color name: https://www.w3schools.com/colors/colors_names.asp
+ */
+export declare const ROOMLE_COLORS: {
+    readonly PRIMARY: 14352384;
+    readonly ON_PRIMARY: 16777215;
+    readonly DEFAULT_BACKGROUND: 16250871;
+    readonly SELECTION: 16777215;
+    readonly PREVIEW_DOCKING_COLOR: 266198493;
+};
+export declare const ROOMLE_HIGHLIGHTNG: {
+    SMART: string;
+    OFF: string;
+    ALWAYS: string;
+};
+export declare const setCursor: (style: CURSOR_STYLE) => void;
+export declare const handleJsonResponse: (response: Response) => Promise<any>;
+export declare const getAssetPath: () => string;
+export declare const uuid: (a?: string) => string;
+export declare const setEnumerable: (target: any, property: string, isEnumerable: boolean) => void;
+export declare const setWriteable: (target: any, property: string, isWritable: boolean) => void;
+export declare const setDescriptor: (target: any, property: string, options: PropertyDescriptor) => void;
+export declare const setPropertiesFromOptions: (target: any, options: any, writeable?: true) => void;
+export declare const createBenchmarkMaterial: (materialId: string) => RapiMaterial;
+export declare const createBenchmarkTexture: (materialId: string) => RapiTexture;
+export declare const createBenchmarkUrl: (materialId: string, size?: number) => string;
+export declare const isString: (value: unknown) => boolean;
+export declare const objectArrayToMap: <K extends V[keyof V], V extends object>(arr: V[], key: keyof V) => Map<K, V>;
+export declare const throttle: <T extends (...args: any[]) => any>(func: T, delay?: number) => (...funcArgs: Parameters<T>) => void;
+/**
+ * Calls the function only if there has been no call for x (param after) milliseconds
+ * @param func
+ * @param after
+ */
+export declare const callAgainAfter: <T extends (...args: any[]) => any>(func: T, after?: number) => (...funcArgs: Parameters<T>) => void;
+export declare const debounce: <Params extends any[]>(func: (...args: Params) => any, timeout: number) => (...args: Params) => void;
+export declare const wait: (delay: number) => Promise<void>;
+export declare const nextTick: () => Promise<void>;
+export declare const roundWithPrecision: (float: number, precision: number) => number;
+export declare const getGlbUrl: (item: RapiItem) => string;
+/**
+ * Recursively merge properties of two objects.
+ * If a property exists in both, property of obj2 is used
+ * @param obj1
+ * @param obj2
+ */
+export declare const deepMerge: (obj1: any, obj2: any) => any;
+export declare const getValue: (value: any, defaultValue: any) => any;
+export declare const removeItem: (arr: any[], element: any) => void;
+export type ValuesFromObject<T> = T[keyof T];
+export declare const copy: <T>(object: T) => T;
+export declare const isWebGl2: () => boolean;
+/**
+ * Creates a proxy around that class that logs all calls to it
+ * @param obj the class to trace
+ * @param name the tag under which it will be logged
+ */
+export declare const traceMethodCalls: (obj: object, name: string) => any;
+/**
+ * Creates a proxy around that class that can be used to track property access
+ * @param obj the class to track
+ * @param name the tag under which it will be logged
+ */
+export declare const trackPropertyAccess: (obj: object, _name: string) => any;
+export declare const getColor: (value: string | number | Color) => Color;
+export declare const isThreeJsColor: (value: any) => value is Color;
+export declare const isHex: (num: string) => boolean;
+export declare const isOnlyNumbers: (num: string) => boolean;
+export declare const parseColorToHexDecimal: (color: string) => number;
+/**
+ * Copies the properties of an incoming material to a kernel material, used mainly
+ * to avoid copying core data when applying a material to a planObject
+ * @param materialPtr Kernel material pointer to apply properties to
+ * @param material material to copy color properties from
+ */
+export declare const applyMaterialToKernelMaterial: (materialPtr: KernelWallMaterial | KernelFloorMaterial, material: BatchPaintMaterial) => KernelWallMaterial | KernelFloorMaterial;
+export declare const download: (filename: string, content: string) => void;
+export declare const areCameraParametersEqual: (start: CameraParameter, end: CameraParameter) => boolean;
+/**
+ * transforms a value from one range (oldMin, oldMax) to a new range (newMin, newMax)
+ * @param value the value to transform
+ * @param oldMin
+ * @param oldMax
+ * @param newMin
+ * @param newMax
+ * @returns the transformed value
+ */
+export declare const transformRange: (value: number, oldMin: number, oldMax: number, newMin: number, newMax: number) => number;
+export declare const hashCode: (value: string) => number;
+export declare const rearrangeArrayByIdOrder: <T extends RapiJson>(idsInOrder: RapiId[], rapiJson: T[], idKey?: string) => T[];
+export declare const promiseWithResolvers: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
+};

package/lib/definitions/packages/common-core/src/utils/dom-helper.d.ts

@@ -0,0 +1,25 @@
+import type { LifeCycleCallbacks } from '../life-cycle-manager';
+import type { Context } from '../di/context';
+import { Vector2 } from 'three';
+export declare const CANVAS_ID: {
+    HSC: string;
+    HSP: string;
+    GLB: string;
+    RMV: string;
+};
+export declare const CONTAINER_CSS_CLASS = "rml-threejs-canvas-container";
+export default class DomHelper implements LifeCycleCallbacks, Context {
+    _creator_: string;
+    private _lifeCycleManager;
+    private _element;
+    private _container;
+    get element(): HTMLElement;
+    constructor(creator: string);
+    setDomElement(element: HTMLElement): void;
+    getClientDimensions(): Vector2;
+    private _removeDomElement;
+    reset(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}

package/lib/definitions/packages/common-core/src/utils/enumerable.d.ts

@@ -0,0 +1,3 @@
+export declare const enumerable: (value: boolean) => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare const isEnumerable: (classInstance: any, name: string) => boolean;
+export declare const getEnumerables: (classInstance: any) => string[];

package/lib/definitions/packages/common-core/src/utils/feature-detection.d.ts

@@ -0,0 +1,6 @@
+export declare const isOldBrowser: () => boolean;
+export declare const hasStaticSupport: () => boolean;
+export declare const hasEs6ModuleSupport: () => boolean;
+export declare const supportsWoff2: () => boolean;
+export declare const hasRequestIdleCallback: () => any;
+export declare const wasmExceptionsSupported: () => boolean;

package/lib/definitions/packages/common-core/src/utils/fps-couter.d.ts

@@ -0,0 +1,12 @@
+export default class FpsCounter {
+    private _index;
+    private _fpsList;
+    private _prevTime;
+    private _frames;
+    private _fps;
+    constructor();
+    update(): void;
+    start(): void;
+    reset(): void;
+    getFps(): number;
+}

package/lib/definitions/packages/common-core/src/utils/global-init-data.d.ts

@@ -0,0 +1,18 @@
+import type { GlobalInitDataDefinition } from './shims';
+import type { Context } from '../di/context';
+import type { RapiServerUrlType } from '../../../typings/rapi-types';
+import type InitData from './init-data';
+export default class GlobalInitData implements Context, GlobalInitDataDefinition {
+    _creator_: string;
+    locale?: string;
+    overrideTenant?: number;
+    overrideCountry?: string;
+    configuratorId?: string;
+    overrideRapi?: RapiServerUrlType;
+    alwaysUseCache?: boolean;
+    customApiUrl?: string;
+    e2e?: boolean;
+    e2eRoomleRendererForImages?: boolean;
+    constructor(creator: string);
+    setOverrides(globalInitData: Partial<GlobalInitDataDefinition> | InitData): void;
+}

package/lib/definitions/packages/common-core/src/utils/init-data.d.ts

@@ -0,0 +1,82 @@
+import { type FeatureFlags, type GlobalInitDataDefinition, type InitDataDefinition, type ThreeJsColorsIn3dScene } from './shims';
+import type { Context } from '../di/context';
+import { ROOMLE_HIGHLIGHTNG } from './common-utils';
+import type { MEASUREMENT_SYSTEM_STRING } from '../../../configurator-core/src/services/unit-formatter';
+import { CAMERA_TYPE } from '../cameracontrol/camera-type';
+import type { Enumify } from '../types';
+import type { DefaultEnvironmentSceneType } from '../webgl/renderer/environment-scene';
+import type { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/shading-settings';
+import type { RapiId } from '../../../typings/rapi-types';
+import type { CanvasOffset } from '../common-interfaces';
+export default class InitData implements Context, Omit<InitDataDefinition, 'colors'> {
+    _creator_: string;
+    autoQuality?: boolean;
+    colors: ThreeJsColorsIn3dScene;
+    isItem?: boolean;
+    id?: RapiId;
+    preloadId?: RapiId;
+    showArButton?: boolean;
+    useRoomlePrice?: boolean;
+    precisionInch?: string;
+    precisionCm?: string;
+    unit?: string;
+    unitStringType?: string;
+    typeChangeTag?: RapiId;
+    preloadHint?: RapiId;
+    offset?: CanvasOffset;
+    startTag?: RapiId;
+    measurementSystem?: Enumify<typeof MEASUREMENT_SYSTEM_STRING>;
+    meshSelection?: boolean;
+    stats?: boolean;
+    _measureTraffic?: boolean;
+    debug?: boolean;
+    usePriceService?: boolean;
+    disableDebugGUI?: boolean;
+    disableEnvMap?: boolean;
+    envMapUrl?: string;
+    envMapIntensity?: number;
+    envMapRotation?: number;
+    maxLightSources?: number;
+    legacyLight?: boolean;
+    sceneLight?: DefaultEnvironmentSceneType;
+    shading?: SceneShadingType;
+    customShading?: CustomShadingParameters;
+    customShadingMoc?: CustomShadingParameters;
+    restrictionLevel?: number;
+    offlineSync?: string;
+    highlighting?: Enumify<typeof ROOMLE_HIGHLIGHTNG>;
+    initialFloorMaterial?: string;
+    dls?: string;
+    ls?: string;
+    floorMaterialsTag?: RapiId;
+    zoomDistance?: number;
+    cameraSpacing?: number;
+    cameraRestriction?: number;
+    verticalCameraAngle?: number;
+    minVerticalCameraAngle?: number;
+    maxVerticalCameraAngle?: number;
+    animateCamera: boolean;
+    horizontalCameraAngle?: number;
+    minHorizontalCameraAngle?: number;
+    maxHorizontalCameraAngle?: number;
+    bananaForScale?: boolean;
+    transparentHighlighting?: boolean;
+    transparentBackground?: boolean;
+    snappingEnabled?: boolean;
+    showInfos?: boolean;
+    showPrice?: boolean;
+    applyCurrentGlobalParameters?: boolean;
+    configureInRoom?: boolean;
+    discardExternalObjectsWhenLoadingPlan?: boolean;
+    featureFlags: FeatureFlags;
+    mode?: Enumify<typeof CAMERA_TYPE>;
+    edit?: boolean;
+    moc?: boolean;
+    /**
+     * If true, the callbacks will only be called if the geometry is ready.
+     * Before RML-8368 false was the default. For more info see there
+     */
+    callbacksOnlyIfGeometryIsReady?: boolean;
+    constructor(creator: string);
+    setOverrides(initData: Partial<InitDataDefinition & GlobalInitDataDefinition> | InitData): void;
+}

package/lib/definitions/packages/common-core/src/utils/kernel-utils.d.ts

@@ -0,0 +1,13 @@
+import type { KernelVector3 } from '../../../typings/kernel';
+import { Euler, Matrix4, Vector3 } from 'three';
+export declare const convertToTHREE: (vector: KernelVector3) => Vector3;
+export declare const convertToThreeLength: (length: number) => number;
+export declare const convertToEuler: (vector: KernelVector3) => Euler;
+export declare const convertToThreeDimensions: (vector: KernelVector3) => Vector3;
+export declare const convertToKernel: (vector: Vector3) => KernelVector3;
+export declare const utilityStringToUTF16: (str: string) => string;
+export declare const convertCObject: (obj: any) => any;
+export declare const utilityToArray: (obj: any) => any[];
+export declare const convertKernelMatrixCoordsToThree: (matrix: Matrix4) => Matrix4;
+export declare const convertToThreeMatrix: (transform: Float32Array) => Matrix4;
+export declare const convertToThreeUVMatrix: (transform: Float32Array) => Matrix4;