zakeke-configurator-react 0.0.190 → 0.0.192

package/dist/declarations/3D/src/Components/AR/AndroidAR.d.ts

@@ -3,5 +3,5 @@ export declare class AndroidAR {
     private static readonly _linkOrTitle;
     private static readonly _noArViewerSigil;
     private static _fallbackInvoked;
-    static openSceneViewer(gltfSrc: any, notifyUnsupportedAR: () => void, arScale?: boolean): void;
+    static openSceneViewer(gltfSrc: any, notifyUnsupportedAR: () => void, arScale?: boolean, anchor?: 'wall' | 'floor' | null): void;
 }

package/dist/declarations/3D/src/Components/SceneHelper.d.ts

@@ -1,4 +1,5 @@
 import { IDisposable } from "../Interfaces/IDisposable";
+import { TryOnFineTuningSettings } from "../Interfaces/ITryOn";
 import { Nullable } from "../types";
 export type WorldExtends = {
     min: BABYLON.Vector3;
@@ -75,6 +76,7 @@ export declare class SceneHelper implements IDisposable {
     getTextureUrl(texture: Nullable<BABYLON.BaseTexture>): Nullable<string>;
     private isEditControl;
     isRealMesh(mesh: BABYLON.AbstractMesh): boolean;
+    meshFineTuningSettings(mesh: BABYLON.AbstractMesh): Nullable<TryOnFineTuningSettings>;
     meshHasParent(meshID: string, parentID: string): boolean;
     countSceneMeshes(): number;
     sceneHasRealMeshes(): boolean;
@@ -84,6 +86,7 @@ export declare class SceneHelper implements IDisposable {
     getInvisibleMeshes(): BABYLON.AbstractMesh[];
     getSubMesh(mesh: BABYLON.AbstractMesh, submeshIdx: number): Nullable<BABYLON.SubMesh>;
     getMeshHierarchy(parentID: string): BABYLON.AbstractMesh[];
+    getTryOnMeshHierarchy(parentID: string): BABYLON.AbstractMesh[];
     isCanvasMesh(mesh: BABYLON.AbstractMesh): boolean;
     isAREnabledForMesh(mesh: BABYLON.AbstractMesh): boolean;
     isTryOnEnabledForMesh(mesh: BABYLON.AbstractMesh): boolean;
@@ -213,6 +216,7 @@ export declare class SceneHelper implements IDisposable {
         arFileUrl: string;
     }[]>;
     private getGltfBlobForARExport;
+    exportMeshToGLBBlob(sceneRootUrl: Nullable<string>, meshID: string): Promise<Blob | null>;
     exportMeshesToARAsync(filePrefix: string, sceneRootUrl: Nullable<string>, meshes: BABYLON.AbstractMesh[], sceneID?: string, sceneCode?: string, fileFormat?: 'usdz' | 'glTF' | 'glb', arScale?: boolean): Promise<string>;
     exportMeshesToARMultiformatAsync(filePrefix: string, sceneRootUrl: Nullable<string>, meshes: BABYLON.AbstractMesh[], formats?: string[], arScale?: boolean): Promise<{
         format: string;

package/dist/declarations/3D/src/Interfaces/ITryOn.d.ts

@@ -0,0 +1,73 @@
+import { Nullable } from "../types";
+export declare enum TryOnType {
+    Eyewear = 1,
+    Shoes = 2,
+    Jewelry = 3,
+    Headwear = 4,
+    Watches = 5
+}
+export interface TryOnProduct {
+    productID: number;
+    typeID: number;
+    providerID: number;
+    settings: string;
+}
+export declare enum TryOnProvider {
+    NotSelected = -1,
+    Mazing = 1,
+    Banuba = 2
+}
+export interface TryOnTypeSettings {
+    try_on: boolean;
+    pd?: boolean;
+    active: boolean;
+}
+export declare enum TryOnSettingsType {
+    VirtualTryOn = "try_on",
+    GlassPupillaryDistanceTool = "pd",
+    StyleButton = "styleButton",
+    MandatoryPupillaryDistance = "mandatoryPD"
+}
+export interface TryOnButtonCustomization {
+    image: Nullable<string>;
+    textLabel: Nullable<string>;
+    textColor: Nullable<string>;
+    backgroundColor: Nullable<string>;
+    borderColor: Nullable<string>;
+    borderWidth: number;
+    borderRadius: number;
+}
+export interface TryOnSettings {
+    type: TryOnType;
+    styleButton: "single" | "multiple";
+    buttonCustomizations: TryOnButtonCustomization[];
+    typeSettings: TryOnTypeSettings;
+}
+export declare enum TryOnFineTuningMazingEnvironment {
+    Neutral = "neutral.hdr",
+    Light = "light.hdr",
+    Bright = "bright.hdr",
+    Studio = "studio.hdr"
+}
+export interface TryOnFineTuningSettings {
+    scale: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+export interface TryOnFineTuningMazingSettings extends TryOnFineTuningSettings {
+    temple: boolean;
+    environment: TryOnFineTuningMazingEnvironment;
+}
+export interface ProductTryOn {
+    productID: number;
+    typeID: TryOnType;
+    providerID: number;
+    settings?: string;
+}
+export interface FineTuningProviderData {
+    mesh?: Blob;
+    settings?: TryOnFineTuningMazingSettings;
+}

package/dist/declarations/3D/src/Viewers/SceneEditor.d.ts

@@ -5,6 +5,7 @@ import { ISceneEditor } from "../Interfaces/ISceneEditor";
 import { LightSelectedEventArgs, LightSelectedEventHandler } from "../Layers/LightsLayer";
 import { Nullable } from "../types";
 import { SceneViewer } from "./SceneViewer";
+import { TryOnSettingsType, TryOnType, TryOnSettings, TryOnProvider, TryOnFineTuningMazingSettings, FineTuningProviderData } from "../Interfaces/ITryOn";
 export declare class MaterialGroup {
     groupName: string;
     materials: BABYLON.Material[];
@@ -94,6 +95,11 @@ export type UploadSceneFileInfo = {
     incrementalsFileLength?: number | null | undefined;
     incrementalsFileUrl?: string | null | undefined;
 };
+export type ProvidersTypesMapping = {
+    list: {
+        [key: string]: number;
+    };
+};
 export type MaterialType = "Standard" | "PBRMetallicRoughness" | "PBRSpecularGlossiness" | "PBR" | "NewPBR";
 export type LightType = "Point" | "Directional" | "Spot" | "Hemispheric";
 export type ObjectSizeType = "width" | "height" | "depth";
@@ -115,6 +121,8 @@ export type MeshLocationsUpdateEventHandler = (evt: Zakeke.SceneMeshLocation[])
 export type ArTaskSuccessEventHandler = () => void;
 export type ArTaskErrorEventHandler = () => void;
 export type ArTasksCheckEventHandler = () => void;
+export type TryOnTaskUpdateFineTuningSettingsEventHandler = (evt: TryOnFineTuningMazingSettings) => void;
+export type TryOnTaskCloseFineTuningEventHandler = () => void;
 export declare class SceneEditor extends SceneViewer implements ISceneEditor, IDisposable {
     private _dracoEnabled;
     private _dracoEncodingSpeed;
@@ -129,6 +137,8 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     private _lightsLayer;
     private _showAxes;
     private _axesLayer;
+    private _showFineTuning;
+    private _fineTuningModelLoaded;
     private _showHighlight;
     private _highlightOver;
     private _highlightOverColor;
@@ -162,6 +172,13 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     private _arTaskSuccessListeners;
     private _arTaskErrorListeners;
     private _arTasksCheckListeners;
+    private _tryOnFineTuningSettingListeners;
+    private _tryOnFineTuningCloseListeners;
+    private _providersTypesMapping;
+    private _pickedProvider;
+    private _providerData;
+    private _sessionTryOnEnabled;
+    private _tryOnInfoLoading;
     private _initialMeshMaterials;
     private _initialSubMeshMaterials;
     private _lastMeshMaterials;
@@ -189,6 +206,14 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     set showLights(value: boolean);
     get showAxes(): boolean;
     set showAxes(value: boolean);
+    get showFineTuning(): boolean;
+    set showFineTuning(value: boolean);
+    set fineTuningModelLoaded(value: boolean);
+    get fineTuningModelLoaded(): boolean;
+    get sessionTryOnEnabled(): boolean;
+    set sessionTryOnEnabled(value: boolean);
+    get tryOnInfoLoading(): boolean;
+    set tryOnInfoLoading(value: boolean);
     get showHighlight(): boolean;
     set showHighlight(value: boolean);
     get highlightOver(): boolean;
@@ -199,6 +224,10 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     set editingMode(value: EditingMode);
     get editControlVisible(): boolean;
     set editControlVisible(value: boolean);
+    get providersTypesMapping(): ProvidersTypesMapping;
+    set providersTypesMapping(value: ProvidersTypesMapping);
+    get selectedProvider(): TryOnProvider;
+    get selectedProviderFineTuningData(): FineTuningProviderData;
     protected constructor(options?: SceneEditorOptions);
     static createSceneEditorAsync(options?: SceneEditorOptions): Promise<SceneEditor>;
     protected createCanvas(): HTMLCanvasElement;
@@ -217,10 +246,18 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     setMatchSameNameTextures(value: boolean): void;
     getAREnabled(): boolean;
     setAREnabled(value: boolean): void;
-    getArOnTheFly(): boolean;
-    setArOnTheFly(value: boolean): void;
+    getAROnTheFly(): boolean;
+    setAROnTheFly(value: boolean): void;
+    setARAnchor(value: 'wall' | 'floor' | null): void;
     getTryOnEnabled(): boolean;
     setTryOnEnabled(value: boolean): void;
+    setTryOnSelectedType(value: TryOnType): void;
+    setProvider(provider: TryOnProvider): void;
+    setProviderFineTuningData(data: FineTuningProviderData): void;
+    getTryOnSelectedType(): TryOnType | null;
+    getTryOnSetting(key: TryOnSettingsType): boolean;
+    setTryOnSetting(key: TryOnSettingsType, value: any): void;
+    setTryOnTypeSettings(settings: TryOnSettings): void;
     getUseDelayedMaterialLoading(): boolean;
     setUseDelayedMaterialLoading(value: boolean): void;
     getUseDelayedTextureLoading(): boolean;
@@ -415,6 +452,12 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     addArTaskErrorListener(listenerFunction: ArTaskErrorEventHandler): void;
     protected fireArTaskCheckEvent(): void;
     addArTaskCheckListener(listenerFunction: ArTasksCheckEventHandler): void;
+    fireFineTuningSettingEvent(settings: TryOnFineTuningMazingSettings): void;
+    addFineTuningSettingListener(listenerFunction: TryOnTaskUpdateFineTuningSettingsEventHandler): number;
+    removeFineTuningSettingListener(listenerIndex: number): void;
+    removeAllFineTuningSettingListeners(): void;
+    fireFineTuningCloseEvent(): void;
+    addFineTuningCloseListener(listenerFunction: TryOnTaskCloseFineTuningEventHandler): void;
     clearListeners(): void;
     protected onPointerDown(evt: PointerEvent, pickInfo: BABYLON.PickingInfo): void;
     protected onPointerMove(evt: BABYLON.IPointerEvent, pickInfo: BABYLON.PickingInfo): void;

package/dist/declarations/3D/src/Viewers/SceneViewer.d.ts

@@ -118,6 +118,7 @@ export declare class SceneViewer implements IDisposable {
     private _isHologram;
     private _lastResizableMeshID;
     private _brandLogoButton;
+    private _performanceInfo;
     get zkScene(): Nullable<Zakeke.Scene>;
     get zkModel(): Nullable<MPlaza.Model>;
     get canvas(): Nullable<HTMLCanvasElement>;
@@ -127,6 +128,7 @@ export declare class SceneViewer implements IDisposable {
     set autoRender(value: boolean);
     get antialias(): boolean;
     set antialias(value: boolean);
+    get isLowEndDevice(): boolean | null;
     get isHologramSource(): boolean;
     set isHologramSource(value: boolean);
     get isHologram(): boolean;
@@ -193,6 +195,8 @@ export declare class SceneViewer implements IDisposable {
     onBeforeRender(): void;
     render(): void;
     protected checkRendering(): void;
+    private resetPerformanceInfo;
+    private checkPerformance;
     protected setupAntialiasPostProcesses(): void;
     protected createAntialiasPostProcesses(): void;
     protected canEnableAntialiasing(): boolean;
@@ -340,6 +344,7 @@ export declare class SceneViewer implements IDisposable {
     private getArFileUrlCacheKey;
     private getCachedArFileUrl;
     private cacheArFileUrl;
+    exportMeshToGLBBlob(meshID: string): Promise<Blob | null>;
     exportSceneToUsdzAsync(sceneID?: string, sceneCode?: string, useCacheWithDesign?: boolean): Promise<Nullable<string>>;
     exportMeshToUsdzAsync(meshID: string): Promise<Nullable<string>>;
     exportSceneToRemoteGlTFAsync(sceneID?: string, sceneCode?: string, useCacheWithDesign?: boolean): Promise<Nullable<string>>;
@@ -360,6 +365,8 @@ export declare class SceneViewer implements IDisposable {
     exportSceneToLocalUSDZAsync(): Promise<string | null>;
     downloadSceneLocalUSDZAsync(): Promise<void>;
     getSceneRootUrl(): Promise<Nullable<string>>;
+    isTryOnMeshVisibleEnabledToShow(): boolean;
+    getTryOnMeshVisible(): BABYLON.Mesh | null;
     refreshInfoPoints(): void;
     private getInfoPointsManagerStyle;
     private updateInfoPointsManagerStyle;

package/dist/declarations/composer/Module/src/components/tryOnViewer.d.ts

@@ -0,0 +1,109 @@
+import { FunctionComponent } from "react";
+import { TryOnFineTuningMazingSettings, TryOnGenericFineTuningSettings, TryOnProduct, TryOnProvider, TryOnSeller, TryOnType } from "../models";
+export declare function parseJSON(json: string): any;
+export declare enum TryOnMode {
+    Undefined = 0,
+    TryOn = 1,
+    PDTool = 2
+}
+export interface TryOnViewerProps {
+    mode: TryOnMode;
+    onTimeout?: (value: boolean) => void;
+    onPDUpdated?: (pd: number) => void;
+    onClose?: () => void;
+}
+export interface VTryOnViewerProps {
+    className?: string;
+    provider: TryOnProvider;
+    type: TryOnType;
+    obj: Blob;
+    settings?: TryOnGenericFineTuningSettings;
+    product: TryOnProduct;
+    customer: TryOnSeller;
+    onReady?: () => void;
+    onClose?: () => void;
+}
+export interface TryOnPDToolProps {
+    className?: string;
+    provider: TryOnProvider;
+    product: TryOnProduct;
+    customer: TryOnSeller;
+    onReady?: () => void;
+    onPDUpdated?: (pd: number) => void;
+    onClose?: () => void;
+}
+export declare const TryOnViewerComponent: FunctionComponent<TryOnViewerProps>;
+export declare const VTryOnViewerComponent: FunctionComponent<VTryOnViewerProps>;
+export declare const TryOnPDToolComponent: FunctionComponent<TryOnPDToolProps>;
+export declare enum MazingTryOnState {
+    Start = "",
+    WaitingAuthentication = "WAITING_AUTH",
+    AuthSuccessful = "AUTH_SUCCESS",
+    TryOnLoaded = "MODEL_LOADED",
+    AuthError = "AUTH_ERROR",
+    WebcamError = "WEBCAM_ERROR",
+    ScreenShotTaken = "SCREENSHOT_TAKEN",
+    WebcamStopped = "WEBCAM_STOPPED"
+}
+export declare enum MazingTryOnOutMessage {
+    StartAuthenticationTryOn = "AUTH_TRY_ON",
+    LoadTryOn = "LOAD_MODEL",
+    TakeScreenshot = "TAKE_SCREENSHOT",
+    StopWebcam = "STOP_WEBCAM"
+}
+export declare enum MazingPDState {
+    Start = "",
+    WaitingAuthentication = "WAITING_AUTH",
+    AuthSuccessful = "AUTH_SUCCESS",
+    PDLoaded = "PD_LOADED",
+    PDUpdated = "NEW_PD",
+    AuthError = "AUTH_ERROR",
+    PDDataNotFoundError = "PD_ERROR",
+    WebcamError = "WEBCAM_ERROR",
+    PDCountdown = "PD_COUNTDOWN",
+    PDCountdownEnd = "PD_COUNTDOWN_END",
+    WebcamStopped = "WEBCAM_STOPPED"
+}
+export declare enum MazingPDOutMessage {
+    StartAuthenticationPD = "AUTH_TRY_ON",
+    LoadPD = "LOAD_PD",
+    StartPD = "START_PD",
+    StopWebcam = "STOP_WEBCAM"
+}
+export interface MazingTryOnInMessage {
+    type: MazingFrameState;
+    value: any;
+}
+export interface MazingFrameProps {
+    className?: string;
+    outMessageHandler: (e: MessageEvent<any>) => void;
+    onReady?: (w: Window) => void;
+}
+export interface MazingTryOnProps {
+    className?: string;
+    obj: Blob;
+    product: TryOnProduct;
+    customer: TryOnSeller;
+    fineTuningSettings?: TryOnFineTuningMazingSettings;
+    initialState?: MazingTryOnInMessage;
+    closeFlag: boolean;
+    onReady?: () => void;
+    onReadyToShow?: () => void;
+    onClosed?: () => void;
+}
+export interface MazingPDProps {
+    className?: string;
+    product: TryOnProduct;
+    customer: TryOnSeller;
+    initialState?: MazingTryOnInMessage;
+    closeFlag: boolean;
+    onReady?: () => void;
+    onReadyToShow?: () => void;
+    onPDUpdated?: (pd: number) => void;
+    onClosed?: () => void;
+    onClose?: () => void;
+}
+export type MazingFrameState = MazingTryOnState | MazingPDState;
+export declare const MazingFrameComponent: (props: MazingFrameProps) => JSX.Element;
+export declare const MazingTryOnComponent: FunctionComponent<MazingTryOnProps>;
+export declare const MazingPDToolComponent: FunctionComponent<MazingPDProps>;

package/dist/declarations/composer/Module/src/index.d.ts

@@ -1,5 +1,6 @@
 export * from './components/customizer';
 export * from './components/sceneViewer';
+export * from './components/tryOnViewer';
 export * from './environment';
 export * from './hooks/useZakeke';
 export * from './models';

package/dist/declarations/libs/pricingRuleBase/DesignPriceCalculatorRuleBased.d.ts

@@ -1,4 +1,3 @@
-import { pricing_model } from "./pricing_model.graphql";
 interface FormulaModel {
     operator: string;
     values: number[];
@@ -24,7 +23,7 @@ export declare class DesignPriceCalculatorRuleBased {
     constructor(apiUrl?: string, token?: string, isOwin?: boolean, cloudFlareApiUrl?: string, clientLang?: string);
     init: (product: any) => Promise<void>;
     getPricings: (product: any, callback: (pricings: any, properties?: PricingRulePropertyModel[]) => void) => Promise<void>;
-    getPricing: (design: any) => pricing_model | undefined;
+    getPricing: (design: any) => any;
     distinct: (value: any, index: any, self: any) => boolean;
     ElementSizeFunction: (pContext: any, formula: FormulaModel) => {
         result: boolean;
@@ -50,9 +49,8 @@ export declare class DesignPriceCalculatorRuleBased {
         conditions: any[];
     }[];
     getFunctionName: (properties: any, rule: any) => any;
-    clearPricings: () => void;
-    GetContextForRule: (rule: any, product: any, design: any) => IContext;
-    isUsingAmountOfColors: (design: any) => boolean;
+    GetContextForRule: (rule: any, product: any, design: any, sidesOnWhichThePriceIsEnabled: any) => IContext;
+    isUsingAmountOfColors: (printTypeID: number) => boolean;
     getPremiumPhotosPrice: (design: any, quantity: number) => number;
     /**
      * Get Image Price
@@ -71,11 +69,11 @@ export declare class DesignPriceCalculatorRuleBased {
     getImagePrice: (design: any, quantity: number) => number;
     getMatchedConditions: (design: any, quantity: number, includePercentage: boolean) => any;
     calculate: (design: any, quantity: number) => number;
-    getPricingAdditionalInfo: (design: any) => {
-        description: string | null;
-        priceDescriptionEnabled: boolean | null;
-        infoPricingText: string | null;
-        priceStructure: import("./pricing_model.graphql").PriceStructure | null;
+    getPricingAdditionalInfo: (printTypeID: number) => {
+        description: any;
+        priceDescriptionEnabled: any;
+        infoPricingText: any;
+        priceStructure: any;
     } | undefined;
 }
 export {};