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

package/src/common/composables/use-materials-and-ral-colors.d.ts

@@ -0,0 +1,10 @@
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+import { RapiId, RapiMaterialGroup } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { AllSampleMaterials } from '../../planner/components/overlays/rooms/utils/ral-colors';
+import { SAMPLE_MATERIALS_ID } from './use-materials-grouped';
+import { Nullable } from '@roomle/web-sdk/lib/definitions/typings/helper';
+import { UseAsyncData } from '../utils/composable-helpers';
+
+type MaterialData = RapiMaterialGroup[] | AllSampleMaterials;
+export declare const useMaterialsAndRalColors: (tagId: Nullable<RapiId | RapiId[] | typeof SAMPLE_MATERIALS_ID>, sdkConnector: SdkConnector) => UseAsyncData<MaterialData>;
+export {};

package/src/common/composables/use-materials-grouped.d.ts

@@ -0,0 +1,10 @@
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+import { RapiId, RapiMaterialGroup } from '@roomle/web-sdk/lib/definitions/typings/rapi-types';
+import { Nullable } from '../utils/types';
+import { UseAsyncData } from '../utils/composable-helpers';
+import { AllSampleMaterials } from '../../planner/components/overlays/rooms/utils/ral-colors';
+
+export declare const SAMPLE_MATERIALS_ID = "__SAMPLE__MATERIALS__";
+type MaterialData = RapiMaterialGroup[] | AllSampleMaterials;
+export declare const useMaterialsGrouped: (tagId: Nullable<RapiId | RapiId[] | typeof SAMPLE_MATERIALS_ID>, sdkConnector: SdkConnector) => UseAsyncData<MaterialData>;
+export {};

package/src/common/composables/use-measurement-styles.d.ts

@@ -0,0 +1,10 @@
+import { ConstructionMeasurementTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/utils/measurements';
+import { WallDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/wall-plan-element-view-model';
+import { CSSProperties } from 'vue';
+
+export declare function useMeasurementsStyles(MIN_VISIBLE_THRESHOLD: number, LINE_EXTRA_PADDING?: number): {
+    calculateLineLength: (measurement: ConstructionMeasurementTransferable | WallDimensionTransferable) => number;
+    getStyles: (measurement: ConstructionMeasurementTransferable | WallDimensionTransferable) => CSSProperties;
+    getLinesStyles: (measurement: ConstructionMeasurementTransferable | WallDimensionTransferable) => CSSProperties;
+    determineDirection: (angleDegrees: number, currentDirection: string) => string;
+};

package/src/common/composables/use-on-click-outside.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+
+export declare const useOnClickOutside: (elementRef: Ref<HTMLElement | undefined>, callback: () => void) => {
+    isListening: Ref<boolean, boolean>;
+    startListening: () => void;
+    stopListening: () => void;
+};

package/src/common/composables/use-planner-actions-visibility.d.ts

@@ -0,0 +1,11 @@
+export declare const usePlannerActionsVisibility: () => {
+    showStartConfiguring: import('vue').ComputedRef<boolean>;
+    showActionButtons: import('vue').ComputedRef<boolean>;
+    showDelete: import('vue').ComputedRef<boolean>;
+    showRotate: import('vue').ComputedRef<boolean>;
+    showDuplicate: import('vue').ComputedRef<boolean>;
+    hasMultiSelection: import('vue').ComputedRef<boolean>;
+    showSwitchProduct: import('vue').ComputedRef<boolean>;
+    showProductFlip: import('vue').ComputedRef<boolean>;
+    selectionIsConstructionElement: import('vue').ComputedRef<boolean>;
+};

package/src/common/composables/use-pointer-pos.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+
+interface UseMouseOptions {
+    touch?: boolean;
+    initialValue?: {
+        x: number;
+        y: number;
+    };
+    target?: any;
+}
+export interface UsePointerPosReturn {
+    x: Ref<number>;
+    y: Ref<number>;
+}
+export declare function usePointerPos(options?: UseMouseOptions): UsePointerPosReturn;
+export {};

package/src/common/composables/use-product-price.d.ts

@@ -0,0 +1,11 @@
+import { Nullable } from '../utils/types';
+import { default as RoomlePlanner } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner';
+import { ProductListItem } from '../../planner/utils/planner-sidebar';
+
+export declare function useProductPrice(product: ProductListItem, api: Nullable<RoomlePlanner>, currencySymbol: Nullable<string>): {
+    priceResult: import('vue').Ref<import('@roomle/web-sdk/lib/definitions/typings/kernel').KernelPartListPrice, import('@roomle/web-sdk/lib/definitions/typings/kernel').KernelPartListPrice>;
+    productPricesSum: import('vue').ComputedRef<number>;
+    price: import('vue').ComputedRef<string>;
+    productQuantity: import('vue').ComputedRef<number>;
+    priceIsZero: import('vue').ComputedRef<boolean>;
+};

package/src/common/composables/use-purchasable-count.d.ts

@@ -0,0 +1,3 @@
+export declare function usePurchasableCount(): {
+    purchasableCount: import('vue').Ref<number, number>;
+};

package/src/common/composables/use-sdk-connector.d.ts

@@ -0,0 +1,3 @@
+import { SdkConnector } from '../../configurator/business-logic/sdk-connector';
+
+export declare const useSdkConnector: () => SdkConnector;

package/src/common/composables/use-sdk-event-emitter-listener.d.ts

@@ -0,0 +1,36 @@
+import { Enumify, Nullable } from '../utils/types';
+import { ConstructionMeasurementsTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/utils/measurements';
+import { ObjectMeasurementsTransferable } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-object-view-model';
+import { EventCallback } from '../business-logic/event-emitter';
+import { MeasurementLineDimensionTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/measurement-line-plan-element-view-model';
+import { NotificationData } from '../components/utils/-utils/notifications';
+import { FloorAreaDataTransferable } from '@roomle/web-sdk/lib/definitions/planner-core/src/view-model/floor-plan-element-view-model';
+import { PLAN_ELEMENT_CHANGE_TYPES } from '@roomle/web-sdk/lib/definitions/planner-core/src/roomle-planner-ui-callback';
+import { CancelSelectionReasons } from '@roomle/web-sdk/lib/definitions/typings/planner';
+import { default as PlanElementViewModel } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-element-view-model';
+
+export declare const SDK_TO_UI_EVENTS: {
+    readonly UPDATE_CONSTRUCTION_MEASUREMENTS: "update-construction-measurements";
+    readonly UPDATE_OBJECT_MEASUREMENTS: "update-object-measurements";
+    readonly UPDATE_MEASUREMENTS_LINE_DIMENSION: "update-measurement-line-dimension";
+    readonly UPDATE_MEASUREMENTS_LINE_STATE: "update-measurement-line-state";
+    readonly SET_NOTIFICATION_STATE: "set-notification-state";
+    readonly FLOORS_AREAS_UPDATED: "floors-areas-updated";
+    readonly PLAN_ELEMENT_CHANGED: "plan-element-changed";
+    readonly UPDATE_CONSTRUCTION_ATTACHED_WALL_ANGLE: "update-construction-attached-wall-angle";
+    readonly SELECTION_CHANGE: "selection-changed";
+    readonly SELECTION_CANCEL: "selection-cancel";
+};
+export interface SDKToUIEventTypes {
+    [SDK_TO_UI_EVENTS.UPDATE_CONSTRUCTION_MEASUREMENTS]: Nullable<ConstructionMeasurementsTransferable>;
+    [SDK_TO_UI_EVENTS.UPDATE_OBJECT_MEASUREMENTS]: Nullable<ObjectMeasurementsTransferable>;
+    [SDK_TO_UI_EVENTS.UPDATE_MEASUREMENTS_LINE_DIMENSION]: Nullable<MeasurementLineDimensionTransferable[]>;
+    [SDK_TO_UI_EVENTS.UPDATE_MEASUREMENTS_LINE_STATE]: boolean;
+    [SDK_TO_UI_EVENTS.PLAN_ELEMENT_CHANGED]: Enumify<typeof PLAN_ELEMENT_CHANGE_TYPES>;
+    [SDK_TO_UI_EVENTS.SET_NOTIFICATION_STATE]: NotificationData;
+    [SDK_TO_UI_EVENTS.FLOORS_AREAS_UPDATED]: FloorAreaDataTransferable[];
+    [SDK_TO_UI_EVENTS.UPDATE_CONSTRUCTION_ATTACHED_WALL_ANGLE]: number;
+    [SDK_TO_UI_EVENTS.SELECTION_CHANGE]: PlanElementViewModel;
+    [SDK_TO_UI_EVENTS.SELECTION_CANCEL]: CancelSelectionReasons;
+}
+export declare const useSDKEventEmitterListener: <T extends keyof SDKToUIEventTypes>(eventName: T, handler: EventCallback<SDKToUIEventTypes[T]>) => void;

package/src/common/composables/use-selected-object-center.d.ts

@@ -0,0 +1,5 @@
+import { Ref } from 'vue';
+import { StoreState } from '../store';
+import { Position2 } from '@roomle/web-sdk/lib/definitions/common-core/src/common-interfaces';
+
+export declare const useSelectedObjectCenter: (store: Store<StoreState>) => Ref<Position2>;

package/src/common/composables/use-selected-plan-element.d.ts

@@ -0,0 +1,7 @@
+import { default as PlanElementViewModel } from '@roomle/web-sdk/lib/definitions/common-core/src/view-model/plan-element-view-model';
+import { StoreState } from '../store';
+
+export declare const useSelectedPlanElement: (store: Store<StoreState>) => {
+    selectionElement: import('vue').ComputedRef<PlanElementViewModel>;
+    hasMultiSelection: import('vue').ComputedRef<boolean>;
+};

package/src/common/composables/use-shared-sidebar-setup.d.ts

@@ -0,0 +1,96 @@
+import { Ref } from 'vue';
+import { BUTTON_ACTIONS } from '../../configurator/store/ui-state';
+import { Enumify, PERSPECTIVE_CAMERA_TYPES } from '../utils/types';
+
+export declare const useSharedSidebarSetup: (topBar: Ref<HTMLElement>) => {
+    currentPerspectiveIcon: Ref<string, string>;
+    isPerspectiveIconsExpanded: Ref<boolean, boolean>;
+    isConfigureInRoomIconsExpanded: Ref<boolean, boolean>;
+    measurementLineDrawingState: Ref<boolean, boolean>;
+    perspectiveIcons: ({
+        name: string;
+        direction: "left";
+        testId: string;
+        tooltip: string;
+    } | {
+        name: string;
+        direction: "center";
+        testId: string;
+        tooltip: string;
+    } | {
+        name: string;
+        direction: "right";
+        testId: string;
+        tooltip: string;
+    } | {
+        name: string;
+        direction: "top";
+        testId: string;
+        tooltip: string;
+    })[];
+    configureInRoomIcons: {
+        name: string;
+        testId: string;
+        tooltip: string;
+    }[];
+    checkboxToggle: Ref<HTMLInputElement, HTMLInputElement>;
+    currentViewMode: import('vue').ComputedRef<any>;
+    isPartlistShown: import('vue').ComputedRef<any>;
+    areDimensionsVisible: import('vue').ComputedRef<any>;
+    numberOfSelectedActions: import('vue').ComputedRef<any>;
+    currentConfigureInRoomIcon: import('vue').ComputedRef<string>;
+    showArButton: import('vue').ComputedRef<boolean>;
+    showConfigureInRoomButton: import('vue').ComputedRef<boolean>;
+    showPartlistButton: import('vue').ComputedRef<boolean>;
+    showMultiselectButton: import('vue').ComputedRef<any>;
+    enableMultiselectButton: import('vue').ComputedRef<boolean>;
+    showDimensionsButton: import('vue').ComputedRef<boolean>;
+    showFullscreenButton: import('vue').ComputedRef<boolean>;
+    showExport3dButton: import('vue').ComputedRef<boolean>;
+    showResetCameraButton: import('vue').ComputedRef<boolean>;
+    showViewModeIcon: import('vue').ComputedRef<boolean>;
+    showViewModeIconMobile: import('vue').ComputedRef<boolean>;
+    showRenderImageButton: import('vue').ComputedRef<boolean>;
+    showSnappingButton: import('vue').ComputedRef<any>;
+    showUndoButton: import('vue').ComputedRef<boolean>;
+    showRedoButton: import('vue').ComputedRef<boolean>;
+    showfirstPersonView: import('vue').ComputedRef<any>;
+    show2dButton: import('vue').ComputedRef<any>;
+    show3dButton: import('vue').ComputedRef<any>;
+    showFpButton: import('vue').ComputedRef<any>;
+    hasMultiSelection: import('vue').ComputedRef<boolean>;
+    isPlanner: import('vue').ComputedRef<any>;
+    hasPlanner: import('vue').ComputedRef<boolean>;
+    isConfiguratorInPlanner: import('vue').ComputedRef<boolean>;
+    isConfiguringInRoom: import('vue').ComputedRef<any>;
+    is2d: import('vue').ComputedRef<any>;
+    is3d: import('vue').ComputedRef<any>;
+    isFp: import('vue').ComputedRef<any>;
+    showMenuButton: import('vue').ComputedRef<any>;
+    enableUndoButton: import('vue').ComputedRef<any>;
+    enableRedoButton: import('vue').ComputedRef<any>;
+    enableHelpCenterButton: import('vue').ComputedRef<boolean>;
+    showHelpCenter: import('vue').ComputedRef<any>;
+    toggleMultiselect: () => Promise<void>;
+    handleMenuToggle: () => Promise<void>;
+    togglePartList: () => Promise<void>;
+    toggleConfigureInRoom: () => Promise<void>;
+    openFullscreen: () => Promise<void>;
+    openExport3D: () => Promise<void>;
+    isPlannerActionActive: (action: BUTTON_ACTIONS) => any;
+    isTopBarActionActive: (action: BUTTON_ACTIONS) => any;
+    toggleDimensions: () => Promise<void>;
+    resetCamera: () => Promise<void>;
+    enableMeasurementLineDrawing: () => Promise<void>;
+    renderImage: () => Promise<void>;
+    toggleSnapping: () => Promise<void>;
+    onUndoOrRedoKey: (event: KeyboardEvent) => void;
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    enable2DView: () => Promise<void>;
+    enable3DView: () => Promise<void>;
+    enableFpView: () => Promise<void>;
+    setCameraPerspective: (angle: Enumify<typeof PERSPECTIVE_CAMERA_TYPES>, newIcon: string) => Promise<void>;
+    showTutorials: () => Promise<void>;
+    isMultiSelectActive: () => any;
+};

package/src/common/composables/use-stage-activity-indicator.d.ts

@@ -0,0 +1,9 @@
+export interface StageActivityIndicatorActions {
+    show: (delay: number) => void;
+    hide: () => void;
+}
+export declare const useStageActivityIndicator: () => {
+    setInstance: (currentInstance: StageActivityIndicatorActions) => StageActivityIndicatorActions;
+    show: (delay: number) => void;
+    hide: () => void;
+};