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

package/packages/web-sdk/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/packages/web-sdk/packages/common-core/src/utils/clipboard-manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Manages clipboard operations (copy and paste) with a fallback to localStorage
+ * if the native Clipboard API is not fully supported.
+ *
+ * Note: The localStorage fallback only works for copy/paste operations within
+ * the same browser tab and origin. It does not interact with the system clipboard.
+ */
+export default class ClipboardManager {
+    private static LOCAL_STORAGE_KEY;
+    /**
+     * Checks if the modern Clipboard API (writeText) is likely supported.
+     * @returns true if navigator.clipboard.writeText is available, false otherwise.
+     */
+    private static hasNativeClipboardWriteSupport;
+    /**
+     * Checks if the modern Clipboard API (readText) is likely supported.
+     * @returns true if navigator.clipboard.readText is available, false otherwise.
+     */
+    private static hasNativeClipboardReadSupport;
+    /**
+     * Copies the given text. It first tries the native Clipboard API.
+     * If that's not available, it falls back to localStorage.
+     *
+     * @param text The string to copy.
+     * @returns A Promise that resolves when the text has been successfully copied
+     */
+    static copy(text: string): Promise<void>;
+    /**
+     * Pastes text. It first tries the native Clipboard API.
+     * If that's not available or fails, it falls back to reading from localStorage.
+     *
+     * @returns A Promise that resolves with the text content (from system clipboard or localStorage).
+     * Resolves with an empty string if localStorage fallback is used and no item is found.
+     * Rejects if both operations fail.
+     * @throws Will throw an error if both native clipboard and localStorage paste operations fail.
+     *
+     * Note: Reading from the system clipboard often requires user permission and the document to be focused.
+     */
+    static paste(): Promise<string>;
+}

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

@@ -0,0 +1,119 @@
+import { RapiId, RapiItem, RapiJson, RapiMaterial, RapiTexture } from '../../../typings/rapi-types';
+import { KernelFloorMaterial, KernelWallMaterial } from '../../../typings/planner';
+import { BatchPaintMaterial } from '../../../planner-core/src/roomle-planner';
+import { Color } from 'three';
+import { 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 type MaybePromise<T> = (() => T) | (() => Promise<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;
+};
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const randomString: (length?: number) => string;
+export declare const deepCopy: <T>(obj: T) => T;
+export declare const isRecord: (value: any) => value is Record<string, any>;
+export declare const getIdQueryParam: (urlString: string) => string | null;
+export declare const isCtrlOrCmd: (event: KeyboardEvent) => boolean;
+export declare const ctrlOrCmd: (event: KeyboardEvent, checkIfItIsTheOnlyKey?: boolean) => boolean;

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

@@ -0,0 +1,28 @@
+import { LifeCycleCallbacks } from '../life-cycle-manager';
+import { 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;
+    getAspectRatio(): number;
+    private _removeDomElement;
+    ensureCanvasFocus(event: MouseEvent): void;
+    reset(): void;
+    pause(): void;
+    resume(): void;
+    destroy(): void;
+}

package/packages/web-sdk/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/packages/web-sdk/packages/common-core/src/utils/external-objects.d.ts

@@ -0,0 +1,7 @@
+import { ExtObjId, ExternalObject } from '../../../typings/external-objects';
+
+export declare const createExtObjId: (id: string) => ExtObjId;
+export declare const removeExtObjIdPrefix: (id: ExtObjId) => string;
+export declare const isExtObjId: (id: unknown) => id is `__ext__obj__#${string}`;
+export declare const isExternalObject: (someThing: unknown) => someThing is ExternalObject;
+export declare const createExtObj: (data: Record<string, unknown>) => Record<string, unknown>;

package/packages/web-sdk/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/packages/web-sdk/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/packages/web-sdk/packages/common-core/src/utils/global-init-data.d.ts

@@ -0,0 +1,19 @@
+import { GlobalInitDataDefinition } from './shims';
+import { Context } from '../di/context';
+import { RapiServerUrlType } from '../../../typings/rapi-types';
+import { default as 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/packages/web-sdk/packages/common-core/src/utils/init-data.d.ts

@@ -0,0 +1,90 @@
+import { FeatureFlags, GlobalInitDataDefinition, InitDataDefinition, ThreeJsColorsIn3dScene } from './shims';
+import { Context } from '../di/context';
+import { ROOMLE_HIGHLIGHTNG } from './common-utils';
+import { MEASUREMENT_SYSTEM_STRING } from '../../../configurator-core/src/services/unit-formatter';
+import { CAMERA_TYPE } from '../cameracontrol/camera-type';
+import { Enumify } from '../types';
+import { DefaultEnvironmentSceneType } from '../webgl/renderer/environment-scene';
+import { CustomShadingParameters, SceneShadingType } from '../webgl/renderer/shading-settings';
+import { RapiId } from '../../../typings/rapi-types';
+import { CanvasOffset } from '../common-interfaces';
+import { ExternalObjectApiConfiguration } from '../../../planner-core/src/external-object-api';
+
+export declare const DEFAULT_ENV_MAP_INTENSITY = 1.5;
+export declare const DEFAULT_ENV_MAP_ROTATION = 0;
+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;
+    debugGeometry?: boolean;
+    usePriceService?: boolean;
+    disableDebugGUI?: boolean;
+    disableEnvMap?: boolean;
+    envMapUrl?: string;
+    envMapIntensity?: number;
+    envMapRotation?: number;
+    maxLightSources?: number;
+    legacyLight?: boolean;
+    sceneLight?: DefaultEnvironmentSceneType;
+    shading?: SceneShadingType;
+    linearAoFilter?: boolean;
+    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;
+    lockPlan: boolean;
+    externalObjectSettings?: ExternalObjectApiConfiguration;
+    /**
+     * 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/packages/web-sdk/packages/common-core/src/utils/kernel-utils.d.ts

@@ -0,0 +1,15 @@
+import { KernelMatrix4, 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 convertKernelMatrixToThreeMatrix: (transform: KernelMatrix4) => Matrix4;
+export declare const convertToThreeMatrix: (transform: Float32Array) => Matrix4;
+export declare const convertToThreeUVMatrix: (transform: Float32Array) => Matrix4;

package/packages/web-sdk/packages/common-core/src/utils/local-storage-helper.d.ts

@@ -0,0 +1,23 @@
+import { Context } from '../di/context';
+
+interface LocalStorageEntry {
+    id: string;
+    date: number;
+    payload: any;
+}
+interface Store {
+    entries: LocalStorageEntry[];
+}
+export declare const DEFAULT_STORE = "rml_default";
+export declare const DEFAULT_STORE_SIZE = 5;
+export default class LocalStorageHelper implements Context {
+    _context_: string;
+    _creator_: string;
+    private _localStorage;
+    constructor(_context_: string);
+    getStore(storeId?: string): Store;
+    saveStore(storeId: string, store: Store): void;
+    addItem(id: string, payload: any, storeId?: string, limit?: number): void;
+    getItem(id: string, storeId?: string): any;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { Context } from '../di/context';
+
+export default class LocalStorage implements Context {
+    _context_: string;
+    _creator_: string;
+    constructor(_context_: string);
+    private get _localStorage();
+    getItem(key: string): any;
+    setItem<T>(key: string, value: T): void;
+}

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

@@ -0,0 +1,10 @@
+import { MeshPhysicalMaterial, MeshStandardMaterial } from 'three';
+
+export default class MaterialCreator {
+    static createMeshPhysicalMaterial(params: {
+        [key: string]: any;
+    }): MeshPhysicalMaterial;
+    static createMeshStandardMaterial(params: {
+        [key: string]: any;
+    }): MeshStandardMaterial;
+}

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

@@ -0,0 +1,10 @@
+import { Position2 } from '../common-interfaces';
+
+export declare const toRadiant: (degree: number) => number;
+export declare const toDegrees: (radians: number) => number;
+export declare const getIdealDistance: (width: number, height: number, depth: number, fov: number, screenWidth: number, screenHeight: number) => number;
+export declare const round: (x: number) => number;
+export declare const getDelta: (v1: Position2, v2: Position2) => number;
+export declare const getAngle: (v1: Position2, v2: Position2) => number;
+export declare const to360Degrees: (radians: number) => number;
+export declare const angleToKernelRotation: (angle: number) => number;

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

@@ -0,0 +1,16 @@
+export declare const enum PARAMETER_UNIT_TYPES {
+    UNKNOWN_UNIT = "unknown",
+    LENGTH = "length",
+    AREA = "area",
+    ANGLE = "angle",
+    COUNT = "count"
+}
+export declare const enum PARAMETER_KERNEL_TYPE {
+    UNKNOWN = "",
+    INTEGER = "Integer",
+    DECIMAL = "Decimal",
+    STRING = "String",
+    BOOLTYPE = "Boolean",
+    MATERIAL = "Material",
+    COLOR = "Color"
+}

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

@@ -0,0 +1,21 @@
+export declare class PromiseQueue<T> {
+    private _waitingPromises;
+    private _callback;
+    private _finishPromiseExecutor;
+    private _errorCallback;
+    constructor(callback?: (results: T[]) => void, errorCallback?: (e: Error) => void);
+    push(promise: Promise<T>): void;
+    /**
+     * Wait for current queue to finish
+     */
+    finished(ignoreErrors?: boolean): Promise<T[]>;
+    /**
+     * Callback whenever queue is finished
+     */
+    registerCallback(callback: (results: T[]) => void): void;
+    unregisterCallback(): void;
+    private _resolveAllExecutors;
+    private _rejectAllExecutors;
+    clear(): void;
+    get length(): number;
+}

package/packages/web-sdk/packages/common-core/src/utils/query-params-helper.d.ts

@@ -0,0 +1,3 @@
+export declare const getAllParameters: (url?: string) => {
+    [key: string]: any;
+};

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

@@ -0,0 +1,11 @@
+import { RapiId } from '../../../typings/rapi-types';
+import { KernelPart } from '../../../typings/kernel';
+
+export declare const isInIframe: () => boolean;
+export declare const getHostname: () => string;
+export declare const NAMES_FOR_LOCALHOST: string[];
+export declare const isDemoHostname: (hostname: string) => boolean;
+export declare const isIdItemId: (id: RapiId) => boolean;
+export declare const getCatalogIdFromItemOrConfigurationId: (id: RapiId) => RapiId;
+export declare const kernelPartToPriceId: ({ articleNr, componentId }: KernelPart) => string;
+export declare const wasRequestSuccess: (ok: boolean | string, status: number | string) => boolean;