@colijnit/configurator 261.1.0 → 261.1.1

package/lib/model/material.d.ts

@@ -0,0 +1,41 @@
+import * as THREE from 'three';
+import { Side } from 'three';
+export declare class Material {
+    name: string;
+    schema: string;
+    specular: THREE.Color;
+    shininess: number;
+    normal: THREE.Texture;
+    texture: THREE.Texture;
+    ao: THREE.Texture;
+    metalness: THREE.Texture;
+    roughness: THREE.Texture;
+    repeatX: number;
+    repeatY: number;
+    loaded: boolean;
+    metalnessValue: number;
+    roughnessValue: number;
+    displacement: THREE.Texture;
+    displacementValue: number;
+    sheen: number;
+    sheenColor: THREE.Color;
+    sheenColorMap: THREE.Texture | null;
+    sheenRoughness: number;
+    sheenRoughnessMap: THREE.Texture | null;
+    emissive: THREE.Texture;
+    emissiveValue: THREE.Color;
+    emissiveIntensityValue: number;
+    envMap: THREE.Texture;
+    envMapIntensity: number;
+    opacity: number;
+    transparent: boolean;
+    reflectivity: number;
+    side: Side;
+    ior: number;
+    transmission: number;
+    thickness: number;
+    specularIntensity: number;
+    transmissionMap: THREE.Texture | null;
+    clearcoatMap: THREE.Texture | null;
+    clearcoatRoughnessMap: THREE.Texture | null;
+}

package/lib/model/metadata.d.ts

@@ -0,0 +1,78 @@
+import * as THREE from 'three';
+import { Euler, Vector3 } from 'three';
+import { DecoNode } from '@colijnit/configuratorapi/build/model/deco-node';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { AdjustableElementInterface } from '../interfaces/adjustable-element.interface';
+import { Texture } from './texture';
+import { Skin } from './skin';
+/** Meta data for items. */
+export interface Metadata {
+    itemName?: string;
+    itemDescription?: string;
+    itemType?: number;
+    /**
+     * InstanceId
+     */
+    itemId?: string;
+    originalItemId?: string;
+    /**
+     * Sku
+     */
+    itemIdentifier?: string;
+    goodId?: string;
+    goodType?: string;
+    isCustom?: boolean;
+    locked?: boolean;
+    configurable?: boolean;
+    ione?: boolean;
+    position?: Vector3;
+    rotation?: number | Euler;
+    scale?: Vector3;
+    centerPivot?: boolean;
+    ignoreInvisible?: boolean;
+    updatePivotOnCreate?: boolean;
+    elementConfiguration?: AdjustableElementInterface[];
+    obsolete?: boolean;
+    thirdPartyModel?: boolean;
+    usePivot?: boolean;
+    decos?: DecoNode[];
+    selections?: Selection[];
+    canElevate?: boolean;
+    onWall?: boolean;
+    modelUrl?: string;
+    scalable?: boolean;
+    scalePercentage?: number;
+    resizable?: boolean;
+    elevation?: number;
+    elevationFixed?: boolean;
+    elevationAdjustable?: boolean;
+    schema?: string;
+    assetPath?: string;
+    texture?: Texture;
+    textureAssetName?: string;
+    skin?: Skin;
+    frameColor?: number;
+    doorColor?: number;
+    windowColor?: THREE.Color;
+    doorpost?: boolean;
+    isGlass?: boolean;
+    itemGroup?: any;
+    canRotateX?: boolean;
+    canRotateY?: boolean;
+    canRotateZ?: boolean;
+    canScaleX?: boolean;
+    canScaleY?: boolean;
+    canScaleZ?: boolean;
+    colorable?: boolean;
+    default180?: boolean;
+    objectUUID?: string;
+    conversionGTMSend?: boolean;
+    conversionSubmittedPrice?: string;
+    hdecoType?: string;
+    opening?: {
+        show: boolean;
+        double: boolean;
+        invertDirection: boolean;
+        invertSide: boolean;
+    };
+}

package/lib/model/render-parameters.d.ts

@@ -0,0 +1,12 @@
+export declare class RenderParameters {
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    iterations?: number;
+    imageWidth?: number;
+    imageHeight?: number;
+    websocket?: string;
+    hdri?: string;
+    hdriIntensity?: number;
+    renderType?: number;
+}

package/lib/model/setting-options.d.ts

@@ -0,0 +1,67 @@
+export declare class SettingOptions {
+    showStockStatus?: boolean;
+    show3DWatermark?: boolean;
+    showZoomButton?: boolean;
+    showTagFilter?: boolean;
+    showAsConfigured?: boolean;
+    development?: boolean;
+    allowLocalSave?: boolean;
+    inlineAnswers?: boolean;
+    showArButton?: boolean;
+    showCaptionAddButton?: boolean;
+    instantReplace?: boolean;
+    bottomAnswers?: boolean;
+    onlyThreeD?: boolean;
+    showRenderConnectionInfo?: boolean;
+    forceAdjustables?: boolean;
+    showRoomDownloadButton?: boolean;
+    showRoomRenderButton?: boolean;
+    showOwnCatalogButton?: boolean;
+    showDownloadButton?: boolean;
+    showOnlyHomeDecoFilter?: boolean;
+    showMeasurementsButton?: boolean;
+    cameraPositionFixed?: boolean;
+    cameraPositionFixedAndScrollbar?: boolean;
+    handleParametric?: boolean;
+    arEnabled?: boolean;
+    showStandaloneARButton?: boolean;
+    vrEnabled?: boolean;
+    qualitySettingsEnabled?: boolean;
+    xrDebug?: boolean;
+    useStandaloneFloors?: boolean;
+    useStandaloneHighLight?: boolean;
+    useCustomFloorSize?: boolean;
+    customFloorSize?: number;
+    showEditPencilConfigurator?: boolean;
+    instantEditMenu?: boolean;
+    animationButton?: boolean;
+    customizationEnabled?: boolean;
+    usePlacementSnapping?: boolean;
+    showWallMeasurements?: boolean;
+    useVariationOnPart?: boolean;
+    showFormDialog?: boolean;
+    showOnlyLastAnswerDescriptionGenericSelection?: boolean;
+    enable3DInPhoto?: boolean;
+    createGlbStandalone?: boolean;
+    useRenderWebsocket?: boolean;
+    productRenderSceneAssetId?: string;
+    pathTracer?: boolean;
+    ssrEnabled?: boolean;
+    maxRenderSamples?: number;
+    aoEnabled?: boolean;
+    aaEnabled?: boolean;
+    vignetteEnabled?: boolean;
+    vignetteOffset?: number;
+    vignetteDarkness?: number;
+    useCanvasImage?: boolean;
+    useThumbnailImage?: boolean;
+    showProgressBar?: boolean;
+    showProgressText?: boolean;
+    showSelectionLoader?: boolean;
+    useAnimations?: boolean;
+    useThreedScene?: boolean;
+    showSlowConnectionWarning?: boolean;
+    useExternalOpenSave?: boolean;
+    floorFadeStart?: number;
+    floorFadeEnd?: number;
+}

package/lib/model/settings.d.ts

@@ -0,0 +1,10 @@
+import { NavigatorType } from '../enum/navigator-type.enum';
+import { PostProcessingSetting } from '../interfaces/post-processing-setting.interface';
+import { SettingInterface } from '../interfaces/setting.interface';
+export declare class Setting {
+    navigatorType: NavigatorType;
+    default: boolean;
+    standalone: boolean;
+    postProcessing: PostProcessingSetting;
+    static CreateModelFromInterface(modelInterface: SettingInterface): Setting;
+}

package/lib/model/shadow-properties.d.ts

@@ -0,0 +1,7 @@
+import { Vector2 } from 'three';
+export declare class ShadowProperties {
+    mapSize: Vector2;
+    radius: number;
+    near: number;
+    far: number;
+}

package/lib/model/skin.d.ts

@@ -0,0 +1,15 @@
+import { Texture } from './texture';
+export interface Skin {
+    [face: string]: SkinFragment;
+}
+export interface SkinFragment {
+    color?: number;
+    texture?: Texture;
+}
+export interface RectangularSkinFragment extends SkinFragment {
+    width(): number;
+    height(): number;
+}
+export interface BoxSkin {
+    [face: string]: RectangularSkinFragment;
+}

package/lib/model/texture.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from 'three';
+import { Vector2 } from 'three';
+import { TextureInterface } from '../interfaces/texture.interface';
+import { TextureType } from '../enum/texture-type';
+import { Metadata } from './metadata';
+export declare class Texture {
+    name: string;
+    type: TextureType;
+    url: string;
+    materializeUrl: string;
+    bumpMap: string;
+    bumpScale: number;
+    roughness: number;
+    roughnessMap: string;
+    normalMap: string;
+    repeatX: number;
+    repeatY: number;
+    metalness: number;
+    metalnessMap: string;
+    aoMapIntensity: number;
+    aoMap: string;
+    alphaMap: string;
+    color: string;
+    emissive: string;
+    data: any;
+    surfaces: string[];
+    offset: THREE.Vector2;
+    scale: number;
+    rotation: number;
+    stretch: boolean;
+    show: boolean;
+    default: boolean;
+    height: number;
+    width: number;
+    tileSize: number;
+    tileRotation: number;
+    dimensions: Vector2;
+    offsetScale: number;
+    useStandalone: boolean;
+    defaultStandalone: boolean;
+    mirror: boolean;
+    simplePlane: boolean;
+    toneMapped: boolean;
+    transparent: boolean;
+    opacity: number;
+    side: THREE.Side;
+    depthWrite: boolean;
+    depthTest: boolean;
+    metadata?: Metadata;
+    static CreateModelFromInterface(modelInterface: TextureInterface): Texture;
+}
+export declare function sameTextures(a: Texture, b: Texture): boolean;

package/{model → lib/model}/variation-settings.d.ts

@@ -1,4 +1,5 @@
-import { BehaviorSubject } from 'rxjs';
+import { Subject } from 'rxjs';
+import { Color, Side } from 'three';
 export declare class VariationSettingsSettings {
     repeatx: number;
     repeaty: number;
@@ -24,31 +25,31 @@ export declare class VariationSettings {
     displacementValue: number;
     displacementFilename: string;
     sheen: number;
-    sheenColor: string;
+    sheenColor: Color;
     sheenColorMap: string;
     sheenColorMapFilename: string;
-    transmissionMap: string;
-    transmissionMapFilename: string;
     sheenRoughness: number;
     sheenRoughnessMap: string;
     sheenRoughnessMapFilename: string;
+    transmissionMap: string;
+    transmissionMapFilename: string;
     emissive: string;
     emissiveFilename: string;
     emissiveIntensity: number;
-    emissiveValue: string;
+    emissiveValue: Color;
     opacity: number;
     transparent: boolean;
     envMap: string;
     envMapFilename: string;
     envMapIntensity: number;
     reflectivity: number;
-    side: number;
+    side: Side;
     transmission: number;
     ior: number;
     thickness: number;
     specularIntensity: number;
-    material: any;
     loading: boolean;
-    loaded: BehaviorSubject<VariationSettings>;
+    loaded: Subject<VariationSettings>;
+    material: any;
     copyFrom(settings: VariationSettings): void;
 }

package/{model → lib/model}/variation.d.ts

@@ -1,3 +1,4 @@
+import { Material } from './material';
 export declare class Variation {
     decoId: number;
     brandId: string;
@@ -6,5 +7,5 @@ export declare class Variation {
     optionText: string;
     supplierArticleNr: string;
     materialId: string;
-    material: any;
+    material: Material;
 }

package/lib/model/xr-reticle.d.ts

@@ -0,0 +1,17 @@
+import { Object3D } from 'three';
+export declare class Reticle extends Object3D {
+    private _rayCaster;
+    /**
+     * @param {XRSession} xrSession
+     * @param {THREE.Camera} camera
+     */
+    constructor();
+    /**
+     * Fires a hit test in the middle of the screen and places the reticle
+     * upon the surface if found.
+     *
+     * @param {XRCoordinateSystem} frameOfRef
+     */
+    update(session: any, camera: any, frameOfRef: any): Promise<void>;
+    toggleValidPosition(valid: boolean): void;
+}

package/lib/modules/render/enum/scene-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum SceneType {
+    Product = "product",
+    Room = "room"
+}

package/lib/modules/render/model/ar-parameters.d.ts

@@ -0,0 +1,9 @@
+export declare class ArParameters {
+    depthOcclusion: boolean;
+    depthHitTest: boolean;
+    anchoredHitTest: boolean;
+    lightEstimation: boolean;
+    reflectionEstimation: boolean;
+    planeDetection: boolean;
+    planeHitTest: boolean;
+}

package/lib/modules/render/model/scene-setting.d.ts

@@ -0,0 +1,13 @@
+import { SceneType } from '../enum/scene-type.enum';
+export declare class SceneSetting {
+    name: string;
+    multiSceneRender: boolean;
+    primarySceneName: string;
+    secondarySceneName?: string;
+    defaultSceneName?: string;
+    hdriIntensity: number;
+    hdriRotation: number;
+    lightingExposure: number;
+    sceneType: SceneType;
+    forceTransparency: boolean;
+}

package/lib/modules/render/model/scene-settings.d.ts

@@ -0,0 +1,4 @@
+import { SceneSetting } from './scene-setting';
+export declare class SceneSettings {
+    scenes: SceneSetting[];
+}

package/lib/pipes/append.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AppendPipe implements PipeTransform {
+    transform(value: string, append?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppendPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AppendPipe, "append">;
+}

package/lib/pipes/google-translate.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { Observable } from 'rxjs';
+import { GoogleTranslateService } from '../services/google-translate.service';
+import * as i0 from "@angular/core";
+export declare class GoogleTranslatePipe implements PipeTransform {
+    private _googleTranslateService;
+    constructor(_googleTranslateService: GoogleTranslateService);
+    transform(value: string): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTranslatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GoogleTranslatePipe, "googleTranslate">;
+}

package/lib/pipes/localize.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DictionaryService } from '../services/dictionary.service';
+import * as i0 from "@angular/core";
+export declare class LocalizePipe implements PipeTransform {
+    private _dictionaryService;
+    constructor(_dictionaryService: DictionaryService);
+    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize">;
+}

package/lib/pipes/pipes.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./append.pipe";
+import * as i2 from "./localize.pipe";
+import * as i3 from "./google-translate.pipe";
+import * as i4 from "./prepend.pipe";
+import * as i5 from "./strip-html.pipe";
+export declare class PipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, [typeof i1.AppendPipe, typeof i2.LocalizePipe, typeof i3.GoogleTranslatePipe, typeof i4.PrependPipe, typeof i5.StripHtmlPipe], never, [typeof i1.AppendPipe, typeof i2.LocalizePipe, typeof i3.GoogleTranslatePipe, typeof i4.PrependPipe, typeof i5.StripHtmlPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
+}

package/lib/pipes/prepend.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PrependPipe implements PipeTransform {
+    transform(value: string, prepend?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrependPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrependPipe, "prepend">;
+}

package/lib/pipes/strip-html.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class StripHtmlPipe implements PipeTransform {
+    transform(html: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StripHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StripHtmlPipe, "stripHtml">;
+}

package/lib/services/app-event.service.d.ts

@@ -0,0 +1,32 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+import { Selection } from '@colijnit/configuratorapi/build/model/selection';
+import { Answer } from '@colijnit/configuratorapi/build/model/answer';
+import { ConfigurationResultObject } from '../model/configuration-result-object';
+import { ConfigurationTemplate } from '../enum/configuration-template.enum';
+import { Article } from '@colijnit/configuratorapi/build/model/article';
+import { IntersectedObjects } from '../model/intersected-objects';
+import * as i0 from "@angular/core";
+export declare class AppEventService {
+    instanceSet: BehaviorSubject<string>;
+    answerCountReceived: BehaviorSubject<number>;
+    readyToRender: BehaviorSubject<boolean>;
+    buildFinished: BehaviorSubject<ConfigurationResultObject>;
+    configurationTemplateChange: BehaviorSubject<ConfigurationTemplate>;
+    articleNotFound: BehaviorSubject<ConfigurationResultObject>;
+    glbCreated: Subject<string>;
+    showOutline: Subject<any>;
+    showErrorOutline: Subject<any>;
+    hideOutline: Subject<void>;
+    articleReceived: Subject<Article>;
+    selectionsReceived: Subject<Selection[]>;
+    answersReceived: Subject<Answer[]>;
+    extraAnswerDataLoaded: Subject<void>;
+    selectionsAndDecosLinked: Subject<void>;
+    connectionReset: Subject<void>;
+    selectSelectionsCalled: Subject<Selection>;
+    articleInfoReceived: Subject<string>;
+    onObjectSelected: Subject<IntersectedObjects>;
+    onObjectUnSelected: Subject<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppEventService>;
+}

package/lib/services/app-initializer.service.d.ts

@@ -0,0 +1,14 @@
+import { BehaviorSubject } from 'rxjs';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import { ConfiguratorSettings } from '../model/configurator-settings';
+import * as i0 from "@angular/core";
+export declare class AppInitializerService {
+    private _settingsService;
+    private _configuratorConnectorService;
+    appInitialized: BehaviorSubject<boolean>;
+    constructor(_settingsService: SettingsService, _configuratorConnectorService: ConfiguratorConnectorService);
+    initializeApp(settings?: ConfiguratorSettings): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppInitializerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppInitializerService>;
+}

package/lib/services/ar.service.d.ts

@@ -0,0 +1,120 @@
+import { OnDestroy } from '@angular/core';
+import { Object3D, Scene, WebGLRenderer } from 'three';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { CameraService } from './camera.service';
+import { SettingsService } from './settings.service';
+import { ConfiguratorConnectorService } from './configurator-connector.service';
+import * as i0 from "@angular/core";
+export declare class ArService implements OnDestroy {
+    private _cameraService;
+    private _settingsService;
+    private _iOne;
+    updateContextMenu: BehaviorSubject<void>;
+    shouldAddObjectToScene: Subject<Object3D>;
+    showConfigurator: boolean;
+    refSpace: any;
+    hitTestSource: any;
+    scene: Scene;
+    userInSelectionMenu: boolean;
+    showContextMenu: boolean;
+    private _arFeatures;
+    private _renderer;
+    private _glBinding;
+    private _session;
+    private _debug;
+    private _surfaceFoundOnce;
+    private _reticle;
+    private _hitTestResult;
+    private _reticleHitTestResult;
+    private _anchoredObjects;
+    private _activeARModel;
+    private _aRModelBackupYPosition;
+    private _aRModelBackupPosition;
+    private _aRModelBackupYRotation;
+    private _aRModelRotationStartingValue;
+    private _vertexList;
+    private _detectedPlanes;
+    private _rawPlanes;
+    private _planeMaterial;
+    private _shadowPlane;
+    private _lastEventTimestamp;
+    private _lastObjectTouchTimestamp;
+    private _doubleTapTimeframe;
+    private _holdingTouch;
+    private _controller;
+    private _raycaster;
+    private _tempMatrix;
+    private _cleanup;
+    private _animating;
+    private _liftAnimation;
+    private _dropAnimation;
+    private _lightProbe;
+    private _threeLightProbe;
+    private _cubeMapTexture;
+    private _depthDataTexture;
+    private _sunLight;
+    private _positionIndicator;
+    private _pointRepresentation;
+    constructor(_cameraService: CameraService, _settingsService: SettingsService, _iOne: ConfiguratorConnectorService);
+    ngOnDestroy(): void;
+    resetPlaneDetection(): Promise<void>;
+    endSessionEvent(): void;
+    arIOSSupported(): Promise<boolean>;
+    arSupported(): Promise<any>;
+    addObjectToARScene(object: Object3D): void;
+    modelLoading(): boolean;
+    modelPlaced(): boolean;
+    handleFrame(xrFrame: any): void;
+    init(renderer: WebGLRenderer): void;
+    savePreSelectionPosition(): void;
+    updateChangedModel(): void;
+    arModeHasBeenActive(): boolean;
+    showMovePhoneAnimation(): boolean;
+    getActiveModel(): any;
+    private _initSession;
+    private _checkAvailableFeatures;
+    private _initRenderer;
+    private _initController;
+    private _initScene;
+    private _initLightEstimation;
+    private _initReflectionCubeMap;
+    private _initCPUDepthOcclusion;
+    private _initAnchoredHitTest;
+    private _initPlaneDetection;
+    private _initLighting;
+    private _checkHitTestMethod;
+    private _executeDepthAnchorHitTest;
+    private _executeAnchoredHitTest;
+    private _executeCPUDepthHitTest;
+    private _executeDefaultHitTest;
+    private _checkExtraFeatures;
+    private _hideOccludedMeshes;
+    private _createPlaneMaterial;
+    private _onSessionStarted;
+    private _onSessionEnded;
+    private _setArModelShadows;
+    private _handleTouchEvent;
+    private _handleMultiTouchEvent;
+    private _handleDoubleTapEvent;
+    private _checkIfHoldTouchEvent;
+    private _handleHoldStartEvent;
+    private _handleHoldEndEvent;
+    private _toggleHoldTouchEvent;
+    private _handleHoldMoveEvent;
+    private _updateShadows;
+    private _adjustLighting;
+    private _toggleARModelTransparency;
+    private _setPlanesVisibilty;
+    private _getObjectIntersections;
+    private _drawPlane;
+    private _drawPlanes;
+    private _callLiftAnimation;
+    private _callDropAnimation;
+    private _createAugmentedMaterial;
+    private _updateAugmentedMaterialUniforms;
+    private _updateMeshMaterials;
+    private _removeMaterialShaders;
+    private _checkingInterfaceInteraction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArService>;
+}