zakeke-configurator-react 0.0.125 → 0.0.127

package/dist/declarations/3D/src/Components/DesignManagers/MeshDesignManager.d.ts

@@ -57,6 +57,7 @@ export declare class MeshDesignManager implements IDisposable {
     private _debouncedUpdateDynamicTexture;
     private _originalViewMatrixValues;
     private _grids;
+    private isFirstRender;
     get showDesign(): boolean;
     set showDesign(value: boolean);
     get side(): Nullable<MPlaza.Side>;

package/dist/declarations/3D/src/Components/Environment/EnvironmentManager.d.ts

@@ -9,8 +9,11 @@ export declare class EnvironmentManager implements IDisposable {
     private _sceneHelper;
     private _environmentHelper;
     private _shadowLight;
+    private _isHologram;
     get scene(): BABYLON.Scene;
-    constructor(zkScene: Zakeke.Scene, scene: BABYLON.Scene);
+    get isHologram(): boolean;
+    set isHologram(value: boolean);
+    constructor(zkScene: Zakeke.Scene, scene: BABYLON.Scene, isHologram?: boolean);
     dispose(): void;
     update(): void;
     configureSkybox(): void;

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

@@ -2,18 +2,18 @@ export interface IScenePreviewOptions {
     width?: number;
     height?: number;
     crop?: boolean;
-    camera?: {
-        alpha: number;
-        beta: number;
+    camera: {
+        position: BABYLON.Vector3;
+        target: BABYLON.Vector3;
     };
     zkScene?: Zakeke.Scene;
     zkModel?: MPlaza.Model;
-    zkDesign?: MPlaza.Design;
+    zkDesign?: MPlaza.Design | null;
     meshesWithCustomizationIds?: string[];
 }
 export declare class ScenePreviewData {
     previewFile: string;
 }
 export declare class ScenesPreview {
-    static getPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, options?: IScenePreviewOptions): Promise<ScenePreviewData>;
+    static getPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, options: IScenePreviewOptions): Promise<ScenePreviewData>;
 }

package/dist/declarations/3D/src/Layers/LightsLayer.d.ts

@@ -1,5 +1,5 @@
-import { ISceneEditor } from "../Interfaces/ISceneEditor";
 import { IDisposable } from "../Interfaces/IDisposable";
+import { ISceneEditor } from "../Interfaces/ISceneEditor";
 export declare type LightSelectedEventArgs = {
     id: string;
     name: string;

package/dist/declarations/3D/src/Misc/WorkerPool.d.ts

@@ -3,8 +3,8 @@ import { IDisposable } from "../Interfaces/IDisposable";
  * Helper class to push actions to a pool of workers.
  */
 export declare class WorkerPool implements IDisposable {
-    private _workerInfos;
-    private _pendingActions;
+    private _workerInfos?;
+    private _pendingActions?;
     /**
      * Constructor
      * @param workers Array of workers to use for actions

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

@@ -418,7 +418,7 @@ export declare class SceneEditor extends SceneViewer implements ISceneEditor, ID
     loadTextureFilesAsync(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string): Promise<void>;
     loadTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, onSuccess?: () => void, onError?: (reason: any) => void): void;
     uploadTextureFileAsync(fileToLoad: File, material: Nullable<BABYLON.Material>): Promise<Nullable<Zakeke.SceneTexture>>;
-    uploadTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, onSuccess?: (zkSceneTextures: Zakeke.SceneTexture[]) => void, onError?: (reason: any) => void): void;
+    uploadTextureFiles(filesToLoad: File[], material: Nullable<BABYLON.Material>, type: string, onSuccess?: (zkSceneTextures: Zakeke.SceneTexture[]) => void, onError?: (reason: any) => void, resize?: boolean): void;
     protected getTexturesUploadUrl(materialID: string): string;
     removeAllMaterialPhotos(material: BABYLON.Material): void;
     removeMaterialPhotoAtIndex(material: BABYLON.Material, index: number): void;

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

@@ -20,6 +20,11 @@ export declare type FocusAttributesEventArgs = {
 };
 export declare type FocusAttributesEventListener = (evt: FocusAttributesEventArgs) => void;
 export declare type ArFileFormat = 'usdz' | 'glTF' | 'glb';
+export declare enum BroadcastChannelEventType {
+    CameraMovement = "camera-movement",
+    ScriptExecution = "script-execution",
+    DesignChanged = "design-changed"
+}
 export declare type DracoDecodingResult = {
     indices?: BABYLON.IndicesArray;
     positions?: BABYLON.FloatArray;
@@ -93,6 +98,9 @@ export declare class SceneViewer implements IDisposable {
     protected _infoPointsManagerStyle: Nullable<InfoPointsManagerStyle>;
     protected _canShowInfoPoints: boolean;
     protected _canShowInfoPointsContent: boolean;
+    private _broadcastChannel;
+    private _isHologramSource;
+    private _isHologram;
     get zkScene(): Zakeke.Scene | null;
     get zkModel(): MPlaza.Model | null;
     get canvas(): Nullable<HTMLCanvasElement>;
@@ -102,6 +110,10 @@ export declare class SceneViewer implements IDisposable {
     set autoRender(value: boolean);
     get antialias(): boolean;
     set antialias(value: boolean);
+    get isHologramSource(): boolean;
+    set isHologramSource(value: boolean);
+    get isHologram(): boolean;
+    set isHologram(value: boolean);
     getAntialiasEnabled(): boolean;
     setAntialiasEnabled(value: boolean): void;
     getARScale(): boolean;
@@ -114,7 +126,7 @@ export declare class SceneViewer implements IDisposable {
     setPrefetchMaterials(value: boolean): void;
     getShowHideInfoPoints(): boolean;
     setShowHideInfoPoints(value: boolean): void;
-    get camera(): BABYLON.Nullable<BABYLON.Camera>;
+    get camera(): Nullable<BABYLON.Camera>;
     get deviceType(): MPlaza.DeviceType;
     set deviceType(value: MPlaza.DeviceType);
     getDeviceType(): MPlaza.DeviceType;
@@ -154,6 +166,9 @@ export declare class SceneViewer implements IDisposable {
     protected disposePostProcesses(): void;
     protected emptyArFileCache(): void;
     resetSceneAsync(): Promise<void>;
+    private closeBroadcastChannel;
+    private openBroadcastChannel;
+    private getOrCreateBroadcastChannel;
     protected createEngine(): void;
     createEmptySceneAsync(): Promise<void>;
     protected setupSceneAsync(): Promise<void>;
@@ -263,7 +278,7 @@ export declare class SceneViewer implements IDisposable {
     addEndSceneLoadingListener(callback: () => void): void;
     private fireEndSceneLoadingEvent;
     getSceneScreenshotAsync(width: number, height: number): Promise<Nullable<string>>;
-    getSceneContentScreenshotAsync(width: any, height: any, padding?: number, zkDesign?: any): Promise<Nullable<string>>;
+    getSceneContentScreenshotAsync(width: any, height: any, padding?: number, zkDesign?: MPlaza.Design | null, legacyScreenshot?: boolean, camera?: Zakeke.SceneCameraLocation): Promise<Nullable<string>>;
     protected preSceneContentScreenshot(): void;
     protected postSceneContentScreenshot(): void;
     protected preSceneMaterialScreenshot(): void;
@@ -337,4 +352,14 @@ export declare class SceneViewer implements IDisposable {
     reloadLoadingErrorTextureAsync(texture: BABYLON.BaseTexture): Promise<void>;
     isTextureLoadingError(texture: BABYLON.BaseTexture): boolean;
     materialHasLoadingErrorTextues(material: BABYLON.Material): boolean;
+    notifyCameraMovement(): void;
+    notifyScriptExecution(script: ComposerScript): void;
+    notifyDesignChanged(zkDesign: MPlaza.Design): void;
+    protected notifyActionExecution(attributeID: Nullable<number>, selectedValue: Nullable<string>, actions: MPlaza.AttributeSceneAction[]): void;
+    protected attachBroadcastChannelEventHandlers(): void;
+    protected detachBroadcastChannelEventHandlers(): void;
+    private onBroadcastMessageReceived;
+    private processCameraMovementEvent;
+    private processScriptExecution;
+    private processDesignChanged;
 }

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

@@ -32,6 +32,8 @@ export declare class ZakekeEnvironment {
     private integration;
     private previewWidth;
     private previewHeight;
+    private clientPreviewWidth;
+    private clientPreviewHeight;
     private shareUrlPrefix;
     private events;
     private zkProduct;
@@ -45,11 +47,16 @@ export declare class ZakekeEnvironment {
     private enableShareCompositionUrl;
     private sharedCompositionDocId;
     private savedCompositions;
+    private isDraftEditor;
+    private isViewerMode;
+    private draftCompositionDocId;
     private initialSelection;
     private undoStack;
     private redoStack;
     currentAttributesSelection: Object | null;
     currentCompositionInfo: CurrentCompositionInfo | null;
+    private pricingCalculator;
+    private copyrightMessageLocalStorageKey;
     sellerSettings: SellerSettings | null;
     get internalProduct(): MPlaza.Model | null;
     get internalScene(): Zakeke.Scene | null;
@@ -76,7 +83,6 @@ export declare class ZakekeEnvironment {
     isExplodedMode: boolean;
     isAssetsLoading: boolean;
     extensionFields: ExtensionFields[];
-    private copyrightMessageLocalStorageKey;
     get isFullscreenMode(): boolean;
     get isViewerReady(): boolean;
     eventMessages: EventMessage[] | null;
@@ -89,6 +95,7 @@ export declare class ZakekeEnvironment {
     private getSettings;
     private getSellerSetting;
     createQuote: (formData: any) => Promise<any>;
+    private loadLocalization;
     private loadScript;
     setCopyrightMessageAccepted: (copyrightMandatoryCheckbox: boolean) => void;
     getCopyrightMessageAccepted: () => boolean;
@@ -154,12 +161,14 @@ export declare class ZakekeEnvironment {
     setCamera(cameraLocationId: string, onlyAngleOfView?: boolean, animate?: boolean): void;
     getCameraByName(name: string): Zakeke.SceneCameraLocation | undefined;
     setCameraLocation(name: string, animate?: boolean): void;
+    private base64StringToFile;
     addToCart: (additionalProperties: Record<string, any>, onBeforeSendDataToParent?: ((data: OnBeforeSendDataToParent) => Promise<void>) | undefined, legacyScreenshot?: boolean | undefined) => Promise<void>;
     zoomIn: () => void;
     zoomOut: () => void;
     isFullscreenEnabled: () => boolean;
     getDesignItemsInfo(): Item[];
     switchFullscreen: () => void;
+    openSecondScreen: () => void;
     private extendedUpdate;
     exportSceneToUsdz: (hash: string) => Promise<string | null | undefined>;
     setExplodedMode: (explodedMode: boolean) => Promise<void>;
@@ -198,11 +207,17 @@ export declare class ZakekeEnvironment {
     getShareCompositionUrl: () => Promise<string>;
     saveCompositionCopy: () => Promise<any>;
     getOnlineScreenshot: (width: number, height: number, legacyScreenshot?: boolean | undefined, backgroundColor?: string | undefined, padding?: number) => Promise<string>;
+    isSceneArOnTheFly: () => boolean | undefined;
+    isArDeviceCompliant: () => boolean;
+    isAndroidOrIOS: () => boolean;
+    isAndroid: boolean;
+    isIOS: boolean;
     private buildModelViewerUrl;
     isSceneArEnabled: () => boolean;
     private getPregeneratedARUrl;
     getQrCodeArUrl: (device: 'iOS' | 'Android') => Promise<string>;
-    getMobileArUrl: (useCacheWithDesign?: boolean | undefined) => Promise<string | null>;
+    getMobileArUrl: (onFlyArUrl?: string | undefined) => Promise<Blob | string | null>;
+    getMobileLocalArUrl: (onFlyArUrl?: string | undefined) => Promise<string | Blob>;
     openArMobile: (url: string) => void;
     private registerView;
     getMeshIDbyName: (name: string) => string | undefined;

package/dist/declarations/composer/Module/src/integrations/Integration.d.ts

@@ -1,4 +1,5 @@
 import { Item } from "..";
+import { DesignPriceCalculatorRuleBased } from "../../../../libs/pricingRuleBase/DesignPriceCalculatorRuleBased";
 export declare class PlatformAttributeSelection {
     attributeCode: string;
     optionCode: string;
@@ -9,7 +10,11 @@ export declare class PlatformAttributeSelection {
     constructor(attributeCode: string, optionCode: string, attributeLabel: string, optionLabel: string, attributeIsEnabled: boolean, optionIsEnabled: boolean);
 }
 export interface Integration {
-    addToCart(composition: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
-    getPrice(composition: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    addToCart(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
+    getPrice(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    getSharedCompositionUrl(compositionDocID: string): Promise<{
+        url: string;
+    }>;
+    setPricingCalculator(pricingCalculator: DesignPriceCalculatorRuleBased): any;
     close(): any;
 }

package/dist/declarations/composer/Module/src/integrations/generic.d.ts

@@ -1,10 +1,16 @@
+import { DesignPriceCalculatorRuleBased } from "../../../../libs/pricingRuleBase/DesignPriceCalculatorRuleBased";
 import { Item } from "../models";
 import { Integration, PlatformAttributeSelection } from "./Integration";
 export default class MerchantIntegrationGeneric implements Integration {
     private readonly callbacks;
     private messageIds;
+    private pricingCalculator;
     constructor();
-    addToCart(composition: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
-    getPrice(composition: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    addToCart(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
+    getPrice(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    getSharedCompositionUrl(compositionDocID: string): Promise<{
+        url: string;
+    }>;
+    setPricingCalculator(pricingCalculator: DesignPriceCalculatorRuleBased): void;
     close(): void;
 }

package/dist/declarations/composer/Module/src/integrations/preview.d.ts

@@ -1,8 +1,13 @@
 import { Item } from "..";
+import { DesignPriceCalculatorRuleBased } from "../../../../libs/pricingRuleBase/DesignPriceCalculatorRuleBased";
 import { Integration, PlatformAttributeSelection } from "./Integration";
 export default class MerchantIntegrationPreview implements Integration {
     constructor();
-    addToCart(composition: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
-    getPrice(composition: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    addToCart(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], designItems: Item[], quantity: number, additionalProperties: Record<string, any>): void;
+    getPrice(composition: any, design: any, model: any, attributes: PlatformAttributeSelection[], compositionPrice: number, quantity: number): Promise<number>;
+    getSharedCompositionUrl(compositionDocID: string): Promise<{
+        url: string;
+    }>;
+    setPricingCalculator(pricingCalculator: DesignPriceCalculatorRuleBased): void;
     close(): void;
 }

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

@@ -15,6 +15,11 @@ export declare class User {
     name: string;
     constructor(id: number, username: string, name: string);
 }
+declare enum ZakekeEnvironment {
+    Customizer = 1,
+    Composer = 2,
+    Viewer = 3
+}
 export declare class Product {
     id: number;
     sku: string;
@@ -24,6 +29,8 @@ export declare class Product {
     areas: ProductArea[];
     quantityRule: ProductQuantityRule | null;
     quoteRule: QuoteRule | null;
+    environment: ZakekeEnvironment | null;
+    isShowSecondScreenEnabled: boolean;
     static fromProduct(zkProduct: any): Product;
 }
 export declare class QuoteRule {
@@ -374,4 +381,13 @@ export interface ExtensionFields {
     label: string;
     formatString: string;
 }
+export interface PreviewCameraImage {
+    id: number;
+    url: string;
+}
+export interface CompositionClientPreview {
+    fileObjectID: number;
+    cameraName: string;
+    url: string;
+}
 export {};

package/dist/declarations/composer/Module/src/state/providerValue.d.ts

@@ -94,6 +94,7 @@ export interface ProviderValue {
     saveComposition: (customPreviewSize?: CustomPreviewSize) => Promise<void>;
     loadComposition: (id: string) => Promise<void>;
     switchFullscreen: () => void;
+    openSecondScreen: () => void;
     isFullscreenMode: boolean;
     zoomIn: () => void;
     zoomOut: () => void;
@@ -115,9 +116,10 @@ export interface ProviderValue {
     highlightGroup: (groupId: number) => void;
     highlightAttribute: (attributeId: number) => void;
     getQrCodeArUrl: (device: 'iOS' | 'Android') => Promise<string>;
-    getMobileArUrl: (useCacheWithDesign?: boolean) => Promise<string | null>;
+    getMobileArUrl: (onFlyArUrl?: string) => Promise<Blob | string | null>;
     openArMobile: (url: string) => void;
     isSceneArEnabled: () => boolean;
+    isArDeviceCompliant: () => boolean;
     IS_ANDROID: boolean;
     IS_IOS: boolean;
     setBackgroundColor: (color: string, alpha: number) => void;

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

@@ -0,0 +1,81 @@
+import { pricing_model } from "./pricing_model.graphql";
+interface FormulaModel {
+    operator: string;
+    values: number[];
+}
+interface PricingRulePropertyModel {
+    propertyID: number;
+    functionName: string;
+}
+interface IContext {
+    sides: any;
+    items: any;
+}
+export declare class DesignPriceCalculatorRuleFactory {
+    static create: (product: any, apiUrl?: string | undefined, token?: string | undefined, isOwin?: boolean | undefined, cloudFlareApiUrl?: string | undefined) => Promise<DesignPriceCalculatorRuleBased>;
+}
+export declare class DesignPriceCalculatorRuleBased {
+    colorID: number;
+    private product?;
+    private pricings?;
+    private pricing?;
+    private properties?;
+    private config;
+    constructor(apiUrl?: string, token?: string, isOwin?: boolean, cloudFlareApiUrl?: string);
+    init: (product: any) => Promise<void>;
+    getPricings: (product: any, callback: (pricings: any, properties?: PricingRulePropertyModel[] | undefined) => void) => Promise<void>;
+    getPricing: (design: any) => pricing_model | undefined;
+    distinct: (value: any, index: any, self: any) => boolean;
+    ElementSizeFunction: (pContext: any, formula: FormulaModel) => {
+        result: boolean;
+        multiplier: number;
+        items: any;
+    };
+    NumberOfElementsSimplifiedFunction: (pContext: any, formula: FormulaModel) => {
+        result: boolean;
+        multiplier: any;
+        items: any;
+    };
+    LinesLengthFunction: (pContext: any, formula: FormulaModel) => any;
+    AmountOfElementsFunction: (pContext: any, formula: FormulaModel) => any;
+    AmountOfUsedColorsFunction: (pContext: any, formula: FormulaModel) => any;
+    CanvasSizeFunction: (pContext: any, formula: FormulaModel) => any;
+    DesignSizeFunction: (pContext: any, formula: FormulaModel) => any;
+    DesignTextLengthFunction: (pContext: any, formula: FormulaModel) => any;
+    CustomizedSidesFunction: (pContext: any, formula: FormulaModel) => any;
+    TextLengthFunction: (pContext: any, formula: FormulaModel) => any;
+    conditionsToConditionsGroupByFormula: (conditions: any) => {
+        formula: string;
+        position: any;
+        conditions: any[];
+    }[];
+    getFunctionName: (properties: any, rule: any) => any;
+    clearPricings: () => void;
+    GetContextForRule: (rule: any, product: any, design: any) => IContext;
+    isUsingAmountOfColors: (design: any) => boolean;
+    getPremiumPhotosPrice: (design: any, quantity: number) => number;
+    /**
+     * Get Image Price
+     *
+     * Metodo che calcola il prezzo per le immagini nel design a cui a backoffice
+     * è stato valorizzato un prezzo
+     *
+     * @author f.checchia
+     *
+     * @param design Il design in input
+     * @param {number} quantity La quantità del prodotto che si sta acquistando
+     *
+     * @return {number} Il prezzo complessivo delle immagini per la quantità
+     *
+     * */
+    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: "CUSTOMIZATION_PRICE" | "FINAL_PRICE" | "SEPARATED_PRICES" | null;
+    } | undefined;
+}
+export {};

package/dist/declarations/libs/pricingRuleBase/pricing_model.graphql.d.ts

@@ -0,0 +1,40 @@
+export declare type PriceStructure = "CUSTOMIZATION_PRICE" | "FINAL_PRICE" | "SEPARATED_PRICES";
+export declare type pricing_model = {
+    readonly id: string;
+    readonly pricingID: number;
+    readonly pricingName: string | null;
+    readonly description: string | null;
+    readonly priceDescriptionEnabled: boolean | null;
+    readonly priceStructure: PriceStructure | null;
+    readonly infoPricingText: string | null;
+    readonly printTypes: ReadonlyArray<{
+        readonly printTypeID: number;
+        readonly printTypeName: string | null;
+    }>;
+    readonly products: ReadonlyArray<{
+        readonly productID: number;
+        readonly productName: string | null;
+    }>;
+    readonly rules: ReadonlyArray<{
+        readonly allMatchType: boolean;
+        readonly elementID: number;
+        readonly elementTitle: string | null;
+        readonly isSetupPrice: boolean;
+        readonly propertyID: number;
+        readonly ruleID: number;
+        readonly priceType: number;
+        readonly conditions: ReadonlyArray<{
+            readonly conditionID: number;
+            readonly formula: string | null;
+            readonly position: number;
+            readonly priceToAdd: unknown;
+            readonly quantity: number;
+        } | null> | null;
+        readonly targets: ReadonlyArray<{
+            readonly area: string | null;
+            readonly color: string | null;
+            readonly side: string | null;
+            readonly targetID: number;
+        } | null> | null;
+    }>;
+};

package/dist/declarations/utils/rectangle.d.ts

@@ -0,0 +1,14 @@
+export declare class Rectangle {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    constructor(width: any, height: any, x: any, y: any);
+    maxX: () => number;
+    maxY: () => number;
+    area: () => number;
+    areaPPCM: (ppcm: number) => number;
+    equals: (rectangleToCompare: Rectangle) => boolean;
+}
+export declare const rectangleArea: (r: Rectangle) => number;
+export declare const rectanglesDistinctArea: (rectangles: Rectangle[], ppcm?: number | undefined) => number;