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

package/packages/web-sdk/packages/typings/external-objects.d.ts

@@ -0,0 +1,20 @@
+import { RapiItem, RapiConfigurationEnhanced, Element, RapiTag } from './rapi-types';
+
+export declare const EXTERNAL_ID_PREFIX = "__ext__obj__#";
+export type ExtObjId = `${typeof EXTERNAL_ID_PREFIX}${string}`;
+interface ExternalMeta {
+    [key: string]: string | number | boolean;
+}
+interface ExternalElement {
+    id: ExtObjId;
+    externalObject: boolean;
+    externalMeta?: ExternalMeta;
+}
+export type ExternalItem = Partial<RapiItem> & Pick<RapiItem, keyof Element> & ExternalElement;
+export type ExternalConfiguration = Partial<RapiConfigurationEnhanced> & Pick<RapiConfigurationEnhanced, keyof Element | 'configurationHash'> & ExternalElement;
+export type ExternalObject = ExternalItem | ExternalConfiguration;
+export type ExternalTag = Partial<RapiTag> & Pick<RapiTag, 'label'> & {
+    id: ExtObjId;
+};
+export type ExternalGroupData = object | string | string[];
+export {};

package/packages/web-sdk/packages/typings/global-definitions.d.ts

@@ -0,0 +1,33 @@
+import { default as SceneManager } from '../common-core/src/webgl/scene-manager';
+import type * as __dat from 'dat.gui';
+import type * as __THREE from 'three';
+interface Debug {
+    raycaster?: boolean;
+    camera?: boolean;
+    boundingBox?: boolean;
+    PlannerKernelContainer?: any;
+    ConfiguratorKernel?: any;
+    Kernel?: any;
+    KernelContainer?: any;
+    Helper?: any;
+    SceneManager?: SceneManager;
+    interactionTimingMs?: number;
+}
+type ThreeShader = string;
+declare global {
+    const THREE: typeof __THREE;
+    const dat: typeof __dat;
+    const WebAssembly: any;
+    interface Window {
+        KernelCallback: {
+            isReady: () => void;
+        };
+        __RML_GUI__: dat.GUI;
+        __RML__DEBUG__: Debug;
+        _rsl: {
+            [key: string]: ThreeShader;
+        };
+    }
+}
+declare const _default: {};
+export default _default;

package/packages/web-sdk/packages/typings/helper.d.ts

@@ -0,0 +1,2 @@
+export type Values<T> = T[keyof T];
+export type Nullable<T> = T | null;

package/packages/web-sdk/packages/typings/kernel.d.ts

@@ -0,0 +1,650 @@
+import { PARAMETER_KERNEL_TYPE, PARAMETER_UNIT_TYPES } from '../common-core/src/utils/parameter-types';
+import { AdditionalInfo, ConfigurationHash, ConfigurationString, PriceId, RapiConfiguration, RapiElement, RapiId, RapiItem, RapiJson, RapiTag } from './rapi-types';
+import { KernelObject } from './planner';
+import { Enumify } from '../common-core/src/types';
+
+import * as ems from './ems';
+declare const BindingError: typeof ems.BindingError, InternalError: typeof ems.InternalError, UnboundTypeError: typeof ems.UnboundTypeError;
+export interface WasmDbEntry {
+    key: string;
+    wasmVersion: string;
+    wasmModule: any;
+}
+export interface KernelVector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface KernelMatrix4 {
+    m: number[];
+}
+export interface KernelValue {
+    value: string;
+    label: string;
+    thumbnail: string;
+}
+export interface KernelActionValue extends KernelValue {
+    value: string;
+    label: string;
+    type: string;
+}
+export interface KernelRange {
+    valueFrom: number;
+    valueTo: number;
+    type: string;
+}
+export interface UiKernelRange {
+    valueFrom: string;
+    valueTo: string;
+    type: string;
+}
+export interface KernelCatalogItem extends KernelObject {
+    configuration: string;
+    flipable: boolean;
+    layer: number;
+    orderable: boolean;
+    scaleable: boolean;
+    size: KernelVector3;
+    type: string;
+    detailType: string;
+}
+export interface ConfigurationObject extends Object {
+    componentId: RapiId;
+    configuration: ConfigurationString;
+    [key: string]: any;
+}
+export interface KernelPossibleChild {
+    externalComponent: boolean;
+    componentId?: RapiId;
+    itemId?: RapiId;
+    isDefault?: boolean;
+    possible: boolean;
+    group: string;
+}
+export interface KernelPartList {
+    originPart: KernelComponent;
+    fullList: KernelPart[];
+    perMainComponent: Array<KernelPartList>;
+}
+export interface KernelPart {
+    articleNr: string;
+    componentId: string;
+    count: number;
+    currencySymbol: string;
+    deletionLocked: boolean;
+    label: string;
+    parameters: KernelPartListParameter[];
+    price: number;
+    retailerPrice: number;
+    [key: string]: any;
+}
+export interface KernelPartListParameter {
+    label: string;
+    type: string;
+    unitType: string;
+    value: string;
+    valueLabel: string;
+    valueThumbnail: string;
+    sort: number;
+}
+export interface KernelPartListPrice {
+    totalSum: number;
+    partMap: Map<PriceId, KernelPart>;
+}
+export declare const PARAMETER_VIEW_TYPE: {
+    readonly EMPTY: 0;
+    readonly TOGGLE: 1;
+    readonly IMAGELIST: 2;
+    readonly IMAGEBIG: 3;
+    readonly IMAGESMALL: 4;
+    readonly INPUTFIELD: 5;
+    readonly DROPDOWN: 6;
+    readonly SLIDER: 7;
+    readonly BUTTON: 8;
+};
+export interface KernelViewType {
+    value: Enumify<typeof PARAMETER_VIEW_TYPE>;
+}
+export interface KernelParameter {
+    enabled: boolean;
+    key: string;
+    label: string;
+    type: PARAMETER_KERNEL_TYPE;
+    value: string;
+    sort: number;
+    unitType: PARAMETER_UNIT_TYPES;
+    validGroups: [RapiId];
+    validRange: KernelRange;
+    validValues: KernelValue[];
+    group: string;
+    visibleInPlanner?: boolean;
+    viewType: KernelViewType;
+    source: 'external' | 'internal';
+    level?: number;
+}
+export interface KernelParameterGroup {
+    key: string;
+    label: string;
+    sort: number;
+    collapsed: boolean;
+}
+export interface KernelEnum {
+    value: number;
+}
+export interface UiKernelParameter extends KernelParameter {
+    uiType: string;
+    validRangeLabels?: UiKernelRange;
+    groups: Promise<RapiJson[]>;
+    valueLabel: string;
+    grouping: KernelParameterGroup;
+    tooltip?: {
+        [key: string]: string;
+    };
+    additionalInfos?: AdditionalInfo[];
+}
+export interface UiPossibleChild extends RapiElement {
+    isItem: boolean;
+    isComponent: boolean;
+    group: string;
+    possible: boolean;
+}
+export interface UiPossibleChildTag extends RapiTag {
+    possibleChildren: UiPossibleChild[];
+}
+export interface DockPair {
+    parentId: number;
+    parentDockId: number;
+    childId: number;
+    childDockId: number;
+    position: KernelVector3;
+    rotation: KernelVector3;
+    insertInBetween: boolean;
+    displacedComponents: number[];
+    displacementRotation: KernelVector3;
+    displacementVector: KernelVector3;
+    [key: string]: any;
+}
+export interface DockingLineSegment {
+    from: number;
+    to: number;
+}
+export interface DockLine {
+    parentId: number;
+    parentDockId: number;
+    childId: number;
+    childDockId: number;
+    position: KernelVector3;
+    rotation: KernelVector3;
+    lineFrom: KernelVector3;
+    lineTo: KernelVector3;
+    lineSegments: DockingLineSegment[];
+    positionFrom: KernelVector3;
+    positionTo: KernelVector3;
+    insertInBetween: boolean;
+    displacedComponents: number[];
+    displacementRotation: KernelVector3;
+    displacementVector: KernelVector3;
+    [key: string]: any;
+}
+export interface KernelCube {
+    origin: KernelVector3;
+    size: KernelVector3;
+}
+export interface KernelAnimation {
+    actions: KernelAnimationAction[];
+    enabled: boolean;
+    key: string;
+    label: string;
+    group: string;
+    sort: number;
+    visibleInPlanner: boolean;
+    level?: number;
+    applyToChildren?: boolean;
+    animate?: boolean;
+}
+export interface KernelAnimationAction {
+    key: string;
+    label: string;
+    type: string;
+}
+export interface PlanObject {
+    bounds: KernelVector3;
+    boxForMeasurement: KernelCube;
+    boxOfGeometry: KernelCube;
+    id: number;
+    rootPlanComponentId: number;
+    externalId: string;
+    externalObject: boolean;
+    dimensioningAxes?: DimensioningAxis[];
+    dimensionings?: Dimensioning[];
+    animations?: KernelAnimation[];
+    [key: string]: any;
+}
+export declare const CONFIGURATION_TYPE: {
+    readonly STATIC: 0;
+    readonly INTERNAL: 1;
+    readonly EXTERNAL: 2;
+};
+export interface ObjectConfigurationType {
+    value: Enumify<typeof CONFIGURATION_TYPE>;
+}
+export interface KernelPlanObjectBase {
+    dimensions: KernelVector3;
+    center: KernelVector3;
+    rootComponentCenter: KernelVector3;
+    rotation: number;
+    customColor: number;
+    customLabel: string;
+    catalogItemId: string;
+    runtimeId: number;
+    configurationType: ObjectConfigurationType;
+    configurationHash: string;
+    configuration: string;
+    configurationRuntimeId: number;
+}
+export interface KernelPlanObject extends KernelPlanObjectBase {
+    parts: KernelPartList;
+    parameters: KernelParameter[];
+    animations?: KernelAnimation[];
+}
+export declare const CORE_PLAN_COMPONENT_TYPE_DTO: {
+    readonly ROOT_COMPONENT: 0;
+    readonly COMPONENT: 1;
+    readonly ROOT_MODULE: 2;
+    readonly SUB_MODULE: 3;
+};
+export interface KernelPlanObjectComponent extends KernelPlanObjectBase {
+    planComponentRuntimeId: number;
+    componentId: string;
+    type: KernelComponentTypeDto;
+    parentObjectId: number;
+    childObjectIds: ems.EmsArray<number>;
+    externalObjectGroupId: string;
+    externalRootModuleId: string;
+    externalSubModuleId: string;
+}
+export interface UiPlanObject extends KernelPlanObject {
+    data: RapiItem | RapiConfiguration | null;
+}
+export interface EmscriptenList {
+    size: () => number;
+    length: number;
+}
+export type EmscriptenString = any;
+export interface EmscriptenMap<K, V> {
+    set: (key: K, value: V) => void;
+    size: () => number;
+}
+export interface KernelComponentTypeDto {
+    value: Enumify<typeof CORE_PLAN_COMPONENT_TYPE_DTO>;
+}
+export interface KernelComponent {
+    [key: string]: any;
+    externalComponent: boolean;
+    type: KernelComponentTypeDto;
+    id: number;
+    valid: boolean;
+    deletionLocked: boolean;
+    objectId: number;
+    rootId: number;
+    rootSiblingIds: number[];
+    parentId: number;
+    childIds: EmscriptenList;
+    label: string;
+    labelIsCalculated: boolean;
+    componentId: string;
+    hash: string;
+    position: KernelVector3;
+    rotation: KernelVector3;
+    transform: KernelMatrix4;
+    globalTransform: KernelMatrix4;
+    bounds: KernelVector3;
+    boundingBox: KernelCube;
+    boxForMeasurement: KernelCube;
+    parameters: KernelParameter[];
+    parameterGroups: KernelParameterGroup[];
+    possibleChildren: KernelPossibleChild[];
+    addOnSpots: AddOnSpot[];
+    dimensioningAxes: DimensioningAxis[];
+    dimensionings: Dimensioning[];
+    animations: KernelAnimation[];
+}
+export interface Dimensioning {
+    axis: string;
+    from: number;
+    to: number;
+    label: string;
+    level: number;
+    visible: boolean;
+    maxLevel: number;
+    interactionKey?: string;
+}
+export interface DimensioningAxis {
+    direction: KernelVector3;
+    key: string;
+    labelDirection: KernelVector3;
+    origin: KernelVector3;
+    alternativeOrigin?: KernelVector3;
+}
+export interface AddOnSpot {
+    position: KernelVector3;
+    mask: string;
+}
+export declare const CORE_ASSET_TYPE: {
+    readonly ITEM: 0;
+    readonly COMPONENT: 1;
+    readonly EXTERNAL_MESH: 2;
+    readonly MATERIAL_PROPERTIES: 3;
+    readonly MATERIAL_GROUP: 4;
+    readonly EXTERNAL_OBJ_URL: 5;
+    readonly EXTERNAL_SVG_URL: 6;
+};
+export interface AssetType {
+    value: Enumify<typeof CORE_ASSET_TYPE>;
+}
+export interface AssetRequest {
+    id: string;
+    value: number;
+    type: AssetType;
+}
+export interface AssetResponse {
+    data: any;
+    id: string;
+    type: AssetType;
+    value?: number;
+}
+export interface KernelContainer {
+    wasmBinaryFile: string;
+    print: (msg: string) => void;
+    printErr: (msg: string) => void;
+    quit: (msg: string) => void;
+    thisProgram: string;
+    reallocBuffer: (size: string) => void;
+    InternalError: typeof InternalError;
+    BindingError: typeof BindingError;
+    UnboundTypeError: typeof UnboundTypeError;
+    wasmTableSize: number;
+    wasmMaxTableSize: number;
+    run: (a: any) => void;
+    abort: (msg: string) => void;
+    noExitRuntime: boolean;
+    usingWasm: boolean;
+    calledRun: boolean;
+    setExternalHelpers: (kernelIo: any, utils: any) => void;
+    registerConfiguratorCallback: (callbacksObject: any) => void;
+    unregisterConfiguratorCallback: (callbacksObject: any) => void;
+}
+export interface KernelDockPairToPoint {
+    parentId: number;
+    parentDockId: number;
+    childId: number;
+    childDockId: number;
+    position: KernelVector3f;
+    rotation: KernelVector3f;
+    insertInBetween: boolean;
+    displacedChildId: number;
+    displacedChildTransform: KernelMatrix4;
+}
+export interface KernelVector2f {
+    x: number;
+    y: number;
+    vectorInRoomleSpace(): KernelVector2f;
+    vectorInKernelSpace(): KernelVector2f;
+    convertToRoomleSpace(): void;
+    convertToKernelSpace(): void;
+}
+export interface KernelVector3f {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface KernelDockingLineSegment {
+    from: number;
+    to: number;
+}
+export interface KernelDockPairToLine {
+    parentId: number;
+    parentDockId: number;
+    childId: number;
+    childDockId: number;
+    position: KernelVector3f;
+    rotation: KernelVector3f;
+    positionFrom: KernelVector3f;
+    positionTo: KernelVector3f;
+    lineFrom: KernelVector3f;
+    lineTo: KernelVector3f;
+    lineSegments: KernelDockingLineSegment[];
+}
+export interface KernelVariable {
+    key: string;
+    type: string;
+    value: string;
+}
+export interface KernelParameterValue {
+    value: string;
+    label: string;
+    thumbnail: string;
+}
+export interface KernelConfiguration {
+    componentId: string;
+    parameters: Map<string, string>;
+    dockParent: string;
+    dockPosition: string;
+    children: KernelConfiguration[];
+}
+export interface KernelAddOnSpot {
+    mask: string;
+    position: KernelVector3f;
+}
+export interface KernelParamKeyValuePair {
+    parameterKey: string;
+    parameterValue: string;
+}
+export interface KernelVariant {
+    componentId: string;
+    articleNr: string;
+    customerPrice: number;
+    retailPrice: number;
+    currencySymbol: string;
+    parameterValues: KernelParameterValue[];
+}
+export interface KernelExternalObjectDocking {
+    groupId: string;
+    parentModuleId: string;
+    moduleName: string;
+}
+export interface ExternalModuleInformation {
+    groupId: string;
+    rootModuleId: string;
+    subModuleId: string;
+}
+export interface KernelObjectInformation {
+    componentId: string;
+    configurationRuntimeId: number;
+    externalModule: ExternalModuleInformation;
+    name: string;
+    runtimeId: number;
+    source: string;
+    type: KernelComponentTypeDto;
+}
+export interface ExternalAttributeInformation {
+    groupId: string;
+    moduleIds: ExternalModuleInformation[];
+    attributeId: string;
+    value: string;
+}
+export declare const enum ExportType {
+    TC = 0,
+    IMOSiX = 1,
+    HOMAGiX = 2
+}
+export interface HomagIxArticleData {
+    name: string;
+    count: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    attributes: string;
+}
+export interface ConfigurationExporter {
+    new (): ConfigurationExporter;
+    init(): void;
+    setDefaultExportDataDefinition(serializedDefaultExportDefinition: string): void;
+    generateExport(exportType: number, planObjectId: number, kernel: ConfiguratorKernelClass): string;
+}
+export interface ConfiguratorKernelClass {
+    setUpdateCallbacksOnlyIfGeometryIsReady(onlyUpdateIfReady: boolean): void;
+    useHDGeometry(requestUseHDGeometry: boolean): void;
+    useEnvironmentGeometry(requestEnvironmentGeometry: boolean): void;
+    setEnvironmentVariable(key: string, value: any): void;
+    setLevel(restrictionLevel: number): void;
+    setDockInsertPreviewBoxParameters(thickness: number, protruding: number, intruding: number, bevelSize: number): void;
+    clearScene(): void;
+    clearAll(): void;
+    loadConfiguration(kernelConversationId: number, configurationObject: ConfigurationString, position: KernelVector3): void;
+    loadPlainComponent(conversationId: number, componentId: RapiId, configuration: ConfigurationString): void;
+    loadFreeFlyingConfiguration(conversationId: number, configuration: ConfigurationString): void;
+    assetsLoaded(assets: AssetResponse | AssetResponse[]): void;
+    deleteComponent(componentId: number): void;
+    deletePlanComponent(componentId: any): void;
+    deletePlanComponents(componentIds: any): void;
+    resetPriceListIds(): void;
+    addPriceList(newLocale: string): void;
+    requestPlanObjectConstruction(planObjectId: number): void;
+    requestPlanComponentConstruction(componentId: number): void;
+    requestDeltaPlanComponentConstruction(componentId: number): void;
+    requestPlanComponentConstructionRecursive(componentId: number): void;
+    requestPreviewGeometry(componentId: number, planObjectId: number, allowInsertInBetween: boolean): void;
+    requestPreviewGeometryForExternalObject(componentId: string, planObjectId: number, allowInsertInBetween: boolean): void;
+    cancelDocking(componentId: number, undoDrag: boolean): void;
+    getComponentParameters(componentId: number): KernelParameter[];
+    getPlanComponentAnimations(planComponentId: number): KernelAnimation[];
+    setComponentParameter(componentId: number, parameterKey: string, value: string): void;
+    setPlanComponentParameters(componentIds: any, parameterKey: string, value: string): void;
+    getPlanObjectParameters(planObjectId: number): KernelParameter[];
+    getPlanObjectAnimations(planObjectId: number): KernelAnimation[];
+    setPlanObjectParameter(planObjectId: number, parameterKey: string, value: string): void;
+    dockComponent(childId: number, childDockId: number, parentId: number, parentDockId: number): void;
+    dockComponentWithPosition(childId: number, childDockId: number, parentId: number, parentDockId: number, position: KernelVector3): void;
+    getExternalObjectDocking(childId: number, childDockId: number, parentId: number, parentDockId: number): KernelExternalObjectDocking;
+    getComponent(componentId: number): KernelComponent;
+    getComponentId(componentId: number): RapiId;
+    isExternalPlanObject(objectOrPlanComponentId: number): boolean;
+    getExternalComponentModuleIds(objectOrPlanComponentId: number): ExternalModuleInformation;
+    getComponentOrModuleInformation(objectOrPlanComponentId: number): KernelObjectInformation;
+    getExternalObjectAttribute(objectOrPlanComponentId: number, attributeKey: string, value: string): ExternalAttributeInformation;
+    getPlanObject(planObjectId: number): PlanObject;
+    getPlanObjectFromPlanComponent(componentId: number): PlanObject;
+    getPlanComponentPossibleChildren(componentId: number): KernelPossibleChild[];
+    getChildrenOfPlanComponent(componentId: number, onlyPossible: boolean, onlyVisible: boolean): KernelPossibleChild[];
+    getChildrenOfPlanObject(planObjectId: number, onlyPossible: boolean, onlyVisible: boolean): KernelPossibleChild[];
+    getPlanObjectPossibleChildren(componentId: number): KernelPossibleChild[];
+    getPlanObjectChildren(planObjectId: number, onlyPossible: boolean, onlyVisible: boolean): KernelPossibleChild[];
+    getRootPlanComponentIdFromObjectId(planObjectId: number): number;
+    getFullPartList(): KernelPartList;
+    getSerializedConfiguration(planObjectOrComponentId: number): ConfigurationString;
+    createNewSerializedConfiguration(configurationRuntimeId: number): ConfigurationString;
+    getHashOfConfiguration(aPlanObjectOrComponentId: number): ConfigurationHash;
+    getHashOfSerializedConfiguration(serializedConfiguration: string): ConfigurationHash;
+    getPartList(getPartList: number): KernelPartList;
+    getCommonPlanComponentParameters(componentIds: any): {
+        parameters: KernelParameter[];
+        parameterGroups: KernelParameterGroup[];
+        animations: KernelAnimation[];
+    };
+    loadComponentDefinition(conversationId: number, component: string): void;
+    syncPlanObjectToView(conversationId: number, planObjectId: number): void;
+    setAssetInvalid(assetType: AssetType, idOrUrl: string, quality: number): void;
+    setActiveGroupInView(groupId: string): void;
+    setActiveGroupInViewForPlanObject(groupId: string, runtimeId: number): void;
+    setUpdateCallbacksOnlyIfGeometryIsReady(updateCallbacksOnlyIfGeometryIsReady: boolean): void;
+    loadExternalAttributeDefinition(serializedDefinition: string): void;
+    setExternalObjectConstructionProperties(serializedProperties: string): void;
+    registerDebugClient(debugClient: DebugClient): void;
+}
+export interface KernelObjectPtrList {
+    size(): void;
+    push_back(object: KernelObject): void;
+}
+export interface ObjectGroupPtr {
+}
+export interface ParamterKeyValue {
+    parameterKey: string;
+    parameterValue: string;
+}
+export interface VariantsList {
+    componentId: string;
+    parameterValues: ParamterKeyValue[];
+    parts: KernelPart[];
+}
+export interface KernelConfigurationLoadedData {
+    conversationId: number;
+    objectId: number;
+    componentId: number;
+    hash: string;
+    errors: string[];
+}
+export type RuntimeId = number;
+export interface KernelMeshBuffer {
+    indices: Int32Array;
+    vertices: Float32Array;
+    normals: Float32Array;
+    uvCoords: Float32Array;
+}
+export interface KernelMeshAnimation {
+    matrix: Float32Array;
+    visibility: boolean;
+    initial: boolean;
+}
+export interface KernelMeshAttributes {
+    materialId: string;
+    materialAttributes: Record<string, string> | null;
+    transform: Float32Array;
+    uvTransform: Float32Array | null;
+    animations: Record<string, KernelMeshAnimation> | null;
+}
+export declare const LIGHT_SOURCE_TYPE: {
+    readonly SPOT: 0;
+    readonly POINT: 1;
+    readonly AREA: 2;
+};
+export interface KernelLightSourceType {
+    value: Enumify<typeof LIGHT_SOURCE_TYPE>;
+}
+export interface KernelLightSourceAttributes {
+    type: KernelLightSourceType;
+    position: KernelVector3f;
+    direction?: KernelVector3f;
+    angle?: number;
+    color?: string;
+    intensity?: number;
+    distance?: number;
+    penumbra?: number;
+    decay?: number;
+    width?: number;
+    height?: number;
+}
+export interface DebugValueMapDump {
+    type: string;
+    componentId: string;
+    internalId: string;
+    id: number;
+    parentId: number;
+    values: Record<string, string>;
+}
+export interface DebugValueMapChange {
+    sourceId: number;
+    sourceInfo: string;
+    valueMaps: Record<string, DebugValueMapDump>;
+}
+export interface DebugClient {
+    debugValueMapChange(changes: DebugValueMapChange): void;
+}
+export {};