@roomle/embedding-lib 5.9.0-alpha.3 → 5.9.0-alpha.4

package/src/common/utils/types.d.ts

@@ -0,0 +1,145 @@
+import { KernelVector3 } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { RapiConfigurationEnhanced, RapiPlanSnapshotGetData, RapiPlan } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { ComponentPublicInstance } from 'vue';
+
+export type Nullable<T> = T | null;
+export type AnyFunction<T = void> = (...args: any[]) => T;
+export type Enumify<T> = T[keyof T];
+export interface CssHash {
+    [key: string]: string;
+}
+export declare const enum USER_ACTION_MODULE {
+    CONFIGURATOR = 3,
+    PLANNER = 1,
+    ROOM_DESIGNER = 8
+}
+export declare enum USER_ACTION {
+    CONVERSION = 11,
+    SHARE_AR = 301,
+    SAVE_DRAFT = 302,
+    ROOM_DESIGNER_SHARE_AR = 801,
+    ROOM_DESIGNER_SAVE_DRAFT = 802
+}
+export type ToggleCallback = (isExpanded: boolean) => void;
+export type CloseReason = 'toggle' | 'close';
+export declare const MEASUREMENT_UNIT: {
+    readonly FEET: "feet";
+    readonly INCH_FEET: "inchfeet";
+    readonly INCH: "inch";
+    readonly CM: "cm";
+    readonly MM: "mm";
+};
+export declare const IMPERIAL_MEASUREMENT_UNITS: {
+    readonly INCH: "inch";
+    readonly INCH_FEET: "inchfeet";
+};
+export declare const METRIC_MEASUREMENT_UNITS: {
+    readonly FEET: "feet";
+    readonly CM: "cm";
+    readonly MM: "mm";
+};
+export declare const MEASUREMENT_SYSTEM: {
+    readonly IMPERIAL: "imperial";
+    readonly METRIC: "metric";
+};
+export declare const DEMO_TYPES: {
+    readonly SUPADEMO: "supademo";
+    readonly YOUTUBE: "youtube";
+    readonly UNKNOWN: "unknown";
+};
+export declare const DEMO_SCOPES: Record<string, CustomTutorialScope>;
+export declare const DEMO_PLATFORMS: Record<string, CustomTutorialPlatform>;
+export declare const PLAN_OBJECT_TYPES: {
+    readonly CONFIGURATION: "configuration";
+    readonly STATIC: "static";
+    readonly WALL: "wall";
+    readonly WINDOW: "window";
+    readonly FLOOR: "floor";
+    readonly DOOR: "door";
+    readonly MEASURE: "measure";
+    readonly UNKNOWN: "unknown";
+};
+export declare const HAS_DRAWER_VIEW_TYPES: Enumify<typeof PLAN_OBJECT_TYPES>[];
+export declare const SIDEBAR_VIEW_NAMES: {
+    readonly WALL: "generalWallSettings";
+    readonly FLOOR: "floorColor";
+    readonly WINDOW: "windowParametersSettings";
+    readonly DOOR: "doorParametersSettings";
+    readonly CONFIGURATION: "productSettings";
+    readonly STATIC: "productSettings";
+    readonly EMBEDDED_INFO: "embeddedInfos";
+};
+export type GroupedCollection<T> = Record<string | symbol, T[]>;
+export declare const RESIZING_ANCHOR: {
+    readonly CENTER: 0;
+    readonly BACK_LEFT: 1;
+    readonly BACK_RIGHT: 2;
+    readonly FRONT_LEFT: 3;
+    readonly FRONT_RIGHT: 4;
+    readonly BACK: 5;
+    readonly FRONT: 6;
+    readonly LEFT: 7;
+    readonly RIGHT: 8;
+};
+export declare const PERSPECTIVE_CAMERA_TYPES: {
+    readonly LEFT: "left";
+    readonly CENTER: "center";
+    readonly RIGHT: "right";
+    readonly TOP: "top";
+};
+export declare const ACTION_BUTTONS: {
+    readonly UNDO_REDO: "z";
+};
+export declare const INTERACTION_VIEW_TYPE: {
+    readonly PARTLIST: "rubens_partlist";
+    readonly MATERIAL_INFO: "material_info";
+    readonly SIDEBAR: "rubens_sidebar";
+};
+export interface GeneralStringObjectType {
+    [key: string]: string;
+}
+export interface ExtendedKernelVector3 extends KernelVector3 {
+    [key: string]: number;
+}
+export declare const CATALOG_INFOS_TYPES: {
+    readonly PARAMETER: "parameter";
+    readonly PARAMETER_VALUE: "paramValue";
+    readonly MATERIAL: "material";
+    readonly COMPONENT: "component";
+    readonly ITEM: "item";
+};
+export interface MessageEventData {
+    eventData: {
+        eventType: 'insertProduct' | 'dragProduct' | 'removeProduct';
+        payload: {
+            productId: string;
+        };
+    };
+}
+export type DraftTypes = 'plan' | 'configuration';
+export interface SaveDraftPayload {
+    type: Nullable<DraftTypes>;
+    payload: Nullable<RapiConfigurationEnhanced | RapiPlanSnapshotGetData | RapiPlan>;
+}
+export interface SaveDraft {
+    id: string;
+    image: string;
+    url: string;
+    data: SaveDraftPayload;
+}
+export interface CustomTutorialTranslation {
+    link: string;
+    label: string;
+    desc?: string;
+    [key: string]: string | undefined;
+}
+export type CustomTutorialScope = 'room-designer' | 'configurator';
+export type CustomTutorialPlatform = 'desktop' | 'mobile';
+export type TutorialData = {
+    scope?: CustomTutorialScope;
+    platform?: CustomTutorialPlatform;
+    en: CustomTutorialTranslation;
+} & {
+    [key: string]: CustomTutorialTranslation | CustomTutorialPlatform | CustomTutorialScope;
+};
+export type TooltipTarget<T> = ComponentPublicInstance<T>;

package/src/common/utils/ui-actions.d.ts

@@ -0,0 +1,38 @@
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+import { StoreState } from '../store';
+import { Store } from 'vuex';
+import { ExposedCallbacks } from '../../configurator/embedding/exposed-callbacks';
+import { Nullable } from './types';
+import { default as PlanElementViewModel } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-element-view-model';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { SidebarType } from '../composables/use-event-emitter-listener';
+import { default as EventEmitter } from '../business-logic/event-emitter';
+
+export declare const scrollToSelectedGroup: (selectedKey: string, direction?: string) => void;
+export declare const isConstructionProduct: (selectionElement: PlanElementViewModel) => boolean;
+export default class UiActions {
+    private _sdkConnector;
+    private _store;
+    private _eventEmitter;
+    constructor(sdkConnector: SdkConnector, store: Store<StoreState>, eventEmitter: EventEmitter);
+    get eventEmitter(): EventEmitter;
+    openCatalog(shouldSwitchVariants?: boolean): Promise<boolean>;
+    closeCatalog(): Promise<void>;
+    toggleInteractionCollapsibleState(active: boolean): boolean;
+    handleAddRoom(): Promise<void>;
+    setHasWallState(): Promise<void>;
+    openAddRoom(): Promise<void>;
+    openNewView(viewName: SidebarType, action: number, expandMobile: boolean): Promise<void>;
+    deleteCurrentSelectedWall(): Promise<void>;
+    activateFirstTimeRoomBehavior(): void;
+    deactivateFirstTimeRoomBehavior(): void;
+    private _expandInteraction;
+    startConfiguring(embeddingCallbacks: ExposedCallbacks): Promise<void>;
+    formatCartItemCount(cartItemsLength: number): string;
+    showBack(): any;
+    preparePartList(buttonAction: number): Promise<void>;
+    private _toggleAction;
+    switchProduct(): Promise<void>;
+    swapObject(api: RoomlePlanner, planElement: PlanElementViewModel, itemId: string): Promise<Nullable<number>>;
+    popSidebar(): void;
+}

package/src/common/utils/user-agent.d.ts

@@ -0,0 +1,7 @@
+import { Nullable } from './types';
+
+export declare const isIOs: () => boolean;
+export declare function hasARQuicklook(): boolean | null;
+export declare const isInAppBrowser: () => Nullable<boolean>;
+export declare const isAndroid: () => boolean;
+export declare const deviceSupportsAR: () => boolean;

package/src/common/utils/variants.d.ts

@@ -0,0 +1,4 @@
+import { Analytics } from '../plugins/analytics';
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+
+export declare const loadVariant: (id: string, applyCurrentGlobalParameters: boolean | undefined, sdkConnector: SdkConnector, analytics?: Analytics) => Promise<void>;

package/src/configurator/ar/AppAR.vue.d.ts

@@ -0,0 +1,11 @@
+import { UiInitData } from '../embedding/types';
+import { RoomleSdkWrapper } from '../business-logic/roomle-sdk-wrapper';
+
+declare const _default: import('vue').DefineComponent<{
+    initData: UiInitData;
+    sdkWrapper: RoomleSdkWrapper;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    initData: UiInitData;
+    sdkWrapper: RoomleSdkWrapper;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/configurator/ar/main.d.ts

@@ -0,0 +1 @@
+export {};

package/src/configurator/business-logic/roomle-sdk-wrapper.d.ts

@@ -0,0 +1,30 @@
+import { default as RapiAccess } from '@roomle/web-sdk/lib/definitions/common-core/src/rapi-access';
+import { GlbViewer } from '@roomle/web-sdk/lib/definitions/glb-viewer-core/src/glb-viewer';
+import { Configurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/configurator';
+import { Nullable } from '../../common/utils/types';
+import { UiInitData } from '../embedding/types';
+import { GlobalInitDataDefinition } from '@roomle/web-sdk/lib/definitions/common-core/src/utils/shims';
+import { Planner } from '@roomle/web-sdk/lib/definitions/planner-core/src/planner';
+import { GlobalCallback } from '@roomle/web-sdk/lib/definitions/common-core/src/services/global-callback';
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+import { default as IdbManager } from '@roomle/web-sdk/lib/definitions/common-core/src/services/idb-manager';
+
+/**
+ * We use this class in a plugin so we
+ * can rely on DI to change it during testing
+ */
+export declare class RoomleSdkWrapper {
+    private _configuratorInstance;
+    private _viewerInstance;
+    private _plannerInstance;
+    private _currentInstance;
+    get hasPlanner(): boolean;
+    getConfigurator(element: HTMLElement, initData?: UiInitData): Promise<Configurator>;
+    getConfiguratorApi(element: HTMLElement, initData?: UiInitData): Promise<RoomleConfigurator>;
+    getGlbViewer(element: HTMLElement, initData?: UiInitData): Promise<GlbViewer>;
+    getPlanner(element: HTMLElement, initData?: UiInitData): Promise<Planner>;
+    getRapiAccess(): Promise<RapiAccess>;
+    getGlobalCallback(): Promise<GlobalCallback>;
+    getStorage(): Nullable<IdbManager>;
+    setGlobalInitData(initData: Nullable<GlobalInitDataDefinition>): void;
+}

package/src/configurator/business-logic/sdk-connector-configurator.d.ts

@@ -0,0 +1,39 @@
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+import { Nullable } from '../../common/utils/types';
+import { UiInitData } from '../embedding/types';
+import { StoreState } from '../../common/store';
+import { KernelParameter } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { Store } from 'vuex';
+import { RoomleSdkWrapper } from './roomle-sdk-wrapper';
+import { Analytics } from '../../common/plugins/analytics';
+import { UiCallbacks } from './ui-callback';
+import { Connector } from '../../common/business-logic/connector';
+import { default as EventEmitter } from '../../common/business-logic/event-emitter';
+
+export declare class SdkConnectorConfigurator extends Connector {
+    private _configurator;
+    private _initWaiters;
+    private _store;
+    private _analytics;
+    private _eventEmitter;
+    private _initData;
+    private _previousParameters;
+    private _uiCallbacks;
+    constructor(store: Store<StoreState>, analytics: Nullable<Analytics>, eventEmitter: EventEmitter);
+    get api(): Promise<RoomleConfigurator>;
+    init(sdkWrapper: RoomleSdkWrapper, element: HTMLElement, initData: UiInitData): Promise<void>;
+    initConfigurator(configurator: RoomleConfigurator): Promise<void>;
+    setParameter(parameter: KernelParameter, value: string, isRaw?: boolean): Promise<void>;
+    setPrice(currencySymbol: string, price: number): void;
+    addUiCallback(listener: UiCallbacks): void;
+    removeUiCallback(listener: UiCallbacks): void;
+    private _checkForLocallySavedConfiguration;
+    saveConfigurationToIdb(): Promise<void>;
+    private _getKeyForIdb;
+    private _pruneLocallySavedPlans;
+    private _updateParameters;
+    private _dispatchNotificationOnGlobalParamChange;
+    private _updateParameterGroups;
+    private _updateAddons;
+    private _checkParameterGroups;
+}

package/src/configurator/business-logic/sdk-connector.d.ts

@@ -0,0 +1,136 @@
+import { Store } from 'vuex';
+import { StoreState } from '../../common/store';
+import { Nullable } from '../../common/utils/types';
+import { KernelParameter, KernelPartList, RuntimeId, UiPossibleChildTag } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+import { default as ConfiguratorUiCallbacks } from '@roomle/web-sdk/lib/definitions/configurator-core/src/services/configurator-ui-callback';
+import { Analytics } from '../../common/plugins/analytics';
+import { RoomleSdkWrapper } from './roomle-sdk-wrapper';
+import { default as RoomleGLBViewer } from '@roomle/web-sdk/lib/definitions/glb-viewer-core/src/roomle-glb-viewer';
+import { default as RapiAccess } from '@roomle/web-sdk/lib/definitions/common-core/src/rapi-access';
+import { MessageHandler } from '../../../packages/common/src/utils/message-handler';
+import { ExposedCallbacks } from '../embedding/exposed-callbacks';
+import { UiInitData } from '../embedding/types';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { SdkConnectorConfigurator } from './sdk-connector-configurator';
+import { SdkConnectorViewer } from '../../viewer/business-logic/sdk-connector-viewer';
+import { SdkConnectorPlanner } from '../../planner/business-logic/sdk-connector-planner';
+import { RapiConfigurationEnhanced, RapiPlan, RapiPlanSnapshotGetData } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { default as RoomleConfigurator } from '@roomle/web-sdk/lib/definitions/configurator-core/src/roomle-configurator';
+import { UiCallbacks } from './ui-callback';
+import { Base64Image } from '@roomle/web-sdk/lib/definitions/common-core/src/common-interfaces';
+import { default as RoomlePlannerUiCallback } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner-ui-callback';
+import { default as AsyncGuard } from '../../common/utils/async-guard';
+import { default as EventEmitter } from '../../common/business-logic/event-emitter';
+import { Translator } from '../../common/composables/use-intl';
+import { Libs } from '../plugins/libs-plugin';
+
+export declare enum SDK_MODULES {
+    VIEWER = 0,
+    CONFIGURATOR = 1,
+    PLANNER = 2
+}
+export interface Selectable {
+    key: string;
+}
+export interface UiPossibleChildTagWithKey extends UiPossibleChildTag {
+    key: string;
+}
+export type LoadResponse = PartlistResponse | void;
+export interface PartlistResponse {
+    partList: KernelPartList;
+}
+export declare const getSelectableEntry: (selected: Selectable, data: Selectable[]) => Nullable<Selectable>;
+export declare const REGISTERED_CALLBACKS: Map<keyof CallbackApi, boolean>;
+export type CallbackApi = ConfiguratorUiCallbacks & RoomlePlannerUiCallback;
+export declare class SdkConnector {
+    protected loadInProgress: boolean;
+    protected someLoadDone: boolean;
+    protected isInitialized: AsyncGuard<void>;
+    private _store;
+    private _loadWaiters;
+    private _analytics;
+    private _sdkWrapper;
+    private _messageHandlers;
+    private _embeddingCallbacks;
+    private _initWaitersConfiguratorConnector;
+    private _initWaitersViewerConnector;
+    private _initWaitersPlannerConnector;
+    private _waitForCanvasElementCallback;
+    private _canvasElement;
+    private _configuratorSettingsCache;
+    private _connectorConfigurator;
+    private _connectorViewer;
+    private _connectorPlanner;
+    private _eventEmitter;
+    private _intl;
+    private _libs;
+    get isE2E(): boolean;
+    get configuratorConnector(): Promise<SdkConnectorConfigurator>;
+    get viewerConnector(): Promise<SdkConnectorViewer>;
+    get plannerConnector(): Promise<SdkConnectorPlanner>;
+    get configuratorApi(): Promise<RoomleConfigurator>;
+    get plannerApi(): Promise<RoomlePlanner>;
+    get viewerApi(): Promise<RoomleGLBViewer>;
+    constructor(sdkWrapper: RoomleSdkWrapper, store: Store<StoreState>, analytics: Analytics, embeddingCallbacks: ExposedCallbacks, eventEmitter: EventEmitter, intl: Translator, libs: Libs);
+    createExposedApi(module: SDK_MODULES, mainMessageHandler: MessageHandler, eventEmitter: EventEmitter): Promise<void>;
+    initialized(): void;
+    getRapiAccess(): Promise<RapiAccess>;
+    waitForLoad(): Promise<Nullable<LoadResponse>>;
+    goBack(): Promise<void>;
+    /**
+     * @deprecated use .configuratorConnector.then((connector) => connector.addUiCallback(listener))
+     * @param listener
+     */
+    addUiCallback(listener: UiCallbacks): void;
+    /**
+     * @deprecated use configuratorConnector.then((connector) => connector.removeUiCallback(listener))
+     * @param listener
+     */
+    removeUiCallback(listener: UiCallbacks): void;
+    setParameter(parameter: KernelParameter, value: string, isRaw?: boolean): Promise<void>;
+    hasActivePackage(): Promise<boolean>;
+    isCorrectConfiguratorDomain(configuratorId: string): Promise<boolean>;
+    private _createPlanAndSelectObj;
+    /**
+     * Load a object which can be one of the following:
+     * - Component (use your component id and prefix it with 'component@', e.g. component@demoCatalogId:externalMeshes)
+     * - Plan
+     * - Static item (e.g. GLB)
+     * - Configurable Item
+     * - Configuration
+     * @param id
+     */
+    loadObject(id: string): Promise<Nullable<LoadResponse>>;
+    loadStaticItem(id: Nullable<string>): Promise<null>;
+    loadPlan(id: Nullable<string>, options?: {
+        isObjectId?: boolean;
+        doNotFinishLoading?: boolean;
+    }): Promise<{
+        plan: Nullable<void> /** Nullable void reserved for later, just to indicate that we could also return something about the plan in the future */;
+        objectRuntimeId: Nullable<RuntimeId>;
+    }>;
+    getStorage(): import('@roomle/web-sdk/lib/definitions/common-core/src/services/idb-manager').default;
+    saveConfigToIdb(): Promise<void>;
+    loadConfiguration(configurationId: string, initData?: UiInitData | undefined): Promise<Nullable<LoadResponse>>;
+    loadComponent(componentId: string, initData?: UiInitData | undefined): Promise<Nullable<LoadResponse>>;
+    loadSelectedPlanObject(shouldStartConfigure?: boolean): Promise<void>;
+    loadConfigurationString(configurationString: string, initData?: UiInitData | undefined): Promise<Nullable<LoadResponse>>;
+    loadConfigurableItem(configurableItemId: string, initData?: UiInitData | undefined): Promise<Nullable<LoadResponse>>;
+    isIdAGlb(id: string): Promise<boolean>;
+    canvasElementReady(element: HTMLElement): void;
+    initCanvasElement(module: SDK_MODULES): Promise<void>;
+    initConfigurator(): Promise<void>;
+    getTenant(): Promise<import('@roomle/web-sdk/lib/definitions/typings/rapi-types').RapiTenant>;
+    saveCurrentConfiguration(): Promise<RapiConfigurationEnhanced>;
+    giveGaConsent(): void;
+    get hasPlanner(): boolean;
+    saveCurrentObject(): Promise<RapiPlan | RapiPlanSnapshotGetData | RapiConfigurationEnhanced>;
+    preparePerspectiveImage(): Promise<Base64Image>;
+    private _finishLoading;
+    private _waitForCanvasElement;
+    private _needsInit;
+    private _fetchVariants;
+    private _execLoadingConfiguratorProcess;
+    private _startLoading;
+    private _selectFirstObjAndStartConfiguring;
+}

package/src/configurator/business-logic/ui-callback.d.ts

@@ -0,0 +1,6 @@
+import { KernelComponent } from '@roomle/web-sdk/lib/definitions/typings/kernel';
+
+export declare class UiCallbacks {
+    onSelectionChange: (_selectionMode: string, _isRoot: boolean, _hasChildren: boolean, _components: KernelComponent[]) => any;
+    onSelectionCancel: () => any;
+}

package/src/configurator/components/ActionButtonsParameterGroups.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{
+    onChangeParameterGroup: () => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onChangeParameterGroup: () => void;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/configurator/components/ConfiguratorMain.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/src/configurator/components/ConfiguratorSidebar.vue.d.ts

@@ -0,0 +1,13 @@
+import { ToggleCallback } from '../../common/utils/types';
+import { EventBus } from '../../common/business-logic/event-bus';
+
+declare const _default: import('vue').DefineComponent<{
+    onToggleExpand: () => void;
+    onToggleEvent: EventBus<ToggleCallback>;
+    onChangeParameterGroup: () => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onToggleExpand: () => void;
+    onToggleEvent: EventBus<ToggleCallback>;
+    onChangeParameterGroup: () => void;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/src/configurator/components/CookieBanner.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{
+    onAccept: () => void;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    onAccept: () => void;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;