@configura/babylon-view 2.0.0-alpha.0 → 2.0.0-alpha.3

package/dist/animation/animator/AnimatorSpin.js

@@ -1,13 +1,13 @@
-import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
-const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { rotationAxis: new Vector3(0, 0, 1) });
-export class AnimatorSpin extends AnimatorEasingMatrix {
-    constructor(node, config, type) {
-        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
-    }
-    getTransformMatrix(boundedEased) {
-        const spin = this._config.startPosition +
-            (this._config.endPosition - this._config.startPosition) * boundedEased;
-        return Matrix.RotationAxis(this._config.rotationAxis, spin);
-    }
-}
+import { Matrix, Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { AnimatorEasingMatrix, getDefaultConfig as baseGetDefaultConfig, } from "./AnimatorEasingMatrix.js";
+const defaultConfig = Object.assign(Object.assign({}, baseGetDefaultConfig(0)), { rotationAxis: new Vector3(0, 0, 1) });
+export class AnimatorSpin extends AnimatorEasingMatrix {
+    constructor(node, config, type) {
+        super(node, Object.assign(Object.assign({}, defaultConfig), config), type);
+    }
+    getTransformMatrix(boundedEased) {
+        const spin = this._config.startPosition +
+            (this._config.endPosition - this._config.startPosition) * boundedEased;
+        return Matrix.RotationAxis(this._config.rotationAxis, spin);
+    }
+}

package/dist/animation/animator/EasingFunctions.d.ts

@@ -1,36 +1,36 @@
-export declare type EasingFunction = (t: number) => number;
-export declare const EasingFunctions: {
-    linear: EasingFunction;
-    easeInQuad: EasingFunction;
-    easeOutQuad: EasingFunction;
-    easeInOutQuad: EasingFunction;
-    easeInCubic: EasingFunction;
-    easeOutCubic: EasingFunction;
-    easeInOutCubic: EasingFunction;
-    easeInQuart: EasingFunction;
-    easeOutQuart: EasingFunction;
-    easeInOutQuart: EasingFunction;
-    easeInQuint: EasingFunction;
-    easeOutQuint: EasingFunction;
-    easeInOutQuint: EasingFunction;
-    sinBounce: (oscillations: number) => EasingFunction;
-    easeInSine: EasingFunction;
-    easeOutSine: EasingFunction;
-    easeInOutSine: EasingFunction;
-    easeInExpo: EasingFunction;
-    easeOutExpo: EasingFunction;
-    easeInOutExpo: EasingFunction;
-    easeInCirc: EasingFunction;
-    easeOutCirc: EasingFunction;
-    easeInOutCirc: EasingFunction;
-    easeInElastic: EasingFunction;
-    easeOutElastic: EasingFunction;
-    easeInOutElastic: EasingFunction;
-    easeInBack: (s?: number) => EasingFunction;
-    easeOutBack: (s?: number) => EasingFunction;
-    easeInOutBack: (s?: number) => EasingFunction;
-    easeOutBounce: EasingFunction;
-    makeMirrored: (func: EasingFunction) => EasingFunction;
-    invert: (func: EasingFunction) => EasingFunction;
-};
+export declare type EasingFunction = (t: number) => number;
+export declare const EasingFunctions: {
+    linear: EasingFunction;
+    easeInQuad: EasingFunction;
+    easeOutQuad: EasingFunction;
+    easeInOutQuad: EasingFunction;
+    easeInCubic: EasingFunction;
+    easeOutCubic: EasingFunction;
+    easeInOutCubic: EasingFunction;
+    easeInQuart: EasingFunction;
+    easeOutQuart: EasingFunction;
+    easeInOutQuart: EasingFunction;
+    easeInQuint: EasingFunction;
+    easeOutQuint: EasingFunction;
+    easeInOutQuint: EasingFunction;
+    sinBounce: (oscillations: number) => EasingFunction;
+    easeInSine: EasingFunction;
+    easeOutSine: EasingFunction;
+    easeInOutSine: EasingFunction;
+    easeInExpo: EasingFunction;
+    easeOutExpo: EasingFunction;
+    easeInOutExpo: EasingFunction;
+    easeInCirc: EasingFunction;
+    easeOutCirc: EasingFunction;
+    easeInOutCirc: EasingFunction;
+    easeInElastic: EasingFunction;
+    easeOutElastic: EasingFunction;
+    easeInOutElastic: EasingFunction;
+    easeInBack: (s?: number) => EasingFunction;
+    easeOutBack: (s?: number) => EasingFunction;
+    easeInOutBack: (s?: number) => EasingFunction;
+    easeOutBounce: EasingFunction;
+    makeMirrored: (func: EasingFunction) => EasingFunction;
+    invert: (func: EasingFunction) => EasingFunction;
+};
 //# sourceMappingURL=EasingFunctions.d.ts.map

package/dist/animation/animator/EasingFunctions.js

@@ -1,137 +1,137 @@
-export const EasingFunctions = {
-    // no easing, no acceleration
-    linear: ((t) => t),
-    // accelerating from zero velocity
-    easeInQuad: ((t) => t * t),
-    // decelerating to zero velocity
-    easeOutQuad: ((t) => t * (2 - t)),
-    // acceleration until halfway, then deceleration
-    easeInOutQuad: ((t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t)),
-    // accelerating from zero velocity
-    easeInCubic: ((t) => t * t * t),
-    // decelerating to zero velocity
-    easeOutCubic: ((t) => --t * t * t + 1),
-    // acceleration until halfway, then deceleration
-    easeInOutCubic: ((t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1),
-    // accelerating from zero velocity
-    easeInQuart: ((t) => t * t * t * t),
-    // decelerating to zero velocity
-    easeOutQuart: ((t) => 1 - --t * t * t * t),
-    // acceleration until halfway, then deceleration
-    easeInOutQuart: ((t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t),
-    // accelerating from zero velocity
-    easeInQuint: ((t) => t * t * t * t * t),
-    // decelerating to zero velocity
-    easeOutQuint: ((t) => 1 + --t * t * t * t * t),
-    // acceleration until halfway, then deceleration
-    easeInOutQuint: ((t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t),
-    sinBounce: (oscillations) => (t) => (1 - Math.cos(t * oscillations * Math.PI * 2)) / 2,
-    easeInSine: ((t) => -Math.cos(t * (Math.PI / 2)) + 1),
-    easeOutSine: ((t) => Math.sin(t * (Math.PI / 2))),
-    easeInOutSine: ((t) => (-1 / 2) * (Math.cos(Math.PI * t) - 1)),
-    easeInExpo: ((t) => (t === 0 ? 0 : Math.pow(2, 10 * (t - 1)))),
-    easeOutExpo: ((t) => (t === 1 ? 1 : -Math.pow(2, -10 * t) + 1)),
-    easeInOutExpo: ((t) => {
-        if (t === 0)
-            return 0;
-        if (t === 1)
-            return 1;
-        if ((t /= 1 / 2) < 1)
-            return (1 / 2) * Math.pow(2, 10 * (t - 1));
-        return (1 / 2) * (-Math.pow(2, -10 * --t) + 2);
-    }),
-    easeInCirc: ((t) => -(Math.sqrt(1 - t * t) - 1)),
-    easeOutCirc: ((t) => Math.sqrt(1 - (t = t - 1) * t)),
-    easeInOutCirc: ((t) => {
-        if (t / 1 / 2 < 1)
-            return (-1 / 2) * (Math.sqrt(1 - t * t) - 1);
-        return (1 / 2) * (Math.sqrt(1 - (t -= 2) * t) + 1);
-    }),
-    easeInElastic: ((t) => {
-        let s = 1.70158;
-        let p = 0;
-        let a = 1;
-        if (t === 0)
-            return 0;
-        if (t === 1)
-            return 1;
-        if (!p)
-            p = 0.3;
-        if (a < Math.abs(1)) {
-            a = 1;
-            s = p / 4;
-        }
-        else {
-            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
-        }
-        return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p));
-    }),
-    easeOutElastic: ((t) => {
-        let s = 1.70158;
-        let p = 0;
-        let a = 1;
-        if (t === 0)
-            return 0;
-        if (t === 1)
-            return 1;
-        if (!p)
-            p = 0.3;
-        if (a < Math.abs(1)) {
-            a = 1;
-            s = p / 4;
-        }
-        else {
-            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
-        }
-        return a * Math.pow(2, -10 * t) * Math.sin(((t - s) * (2 * Math.PI)) / p) + 1;
-    }),
-    easeInOutElastic: ((t) => {
-        let s = 1.70158;
-        let p = 0;
-        let a = 1;
-        if (t === 0)
-            return 0;
-        if (t / 2 === 2)
-            return 1;
-        if (!p)
-            p = 0.3 * 1.5;
-        if (a < 1) {
-            a = 1;
-            s = p / 4;
-        }
-        else {
-            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
-        }
-        if (t < 1)
-            return (-0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p)));
-        return a * Math.pow(2, -10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p) * 0.5 + 1;
-    }),
-    easeInBack: (s = 1.70158) => (t) => t * t * ((s + 1) * t - s),
-    easeOutBack: (s = 1.70158) => (t) => (t = t - 1) * t * ((s + 1) * t + s) + 1,
-    easeInOutBack: (s = 1.70158) => (t) => {
-        if ((t /= 1 / 2) < 1)
-            return (1 / 2) * (t * t * (((s *= 1.525) + 1) * t - s));
-        return (1 / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);
-    },
-    easeOutBounce: ((t) => {
-        if (t < 1 / 2.75) {
-            return 7.5625 * t * t;
-        }
-        else if (t < 2 / 2.75) {
-            return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75;
-        }
-        else if (t < 2.5 / 2.75) {
-            return 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375;
-        }
-        else {
-            return 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
-        }
-    }),
-    makeMirrored: (func) => (t) => {
-        const perceivedT = (t < 0.5 ? t : 1 - t) * 2;
-        return func(perceivedT);
-    },
-    invert: (func) => (t) => {
-        return func(1 - t);
-    },
-};
+export const EasingFunctions = {
+    // no easing, no acceleration
+    linear: ((t) => t),
+    // accelerating from zero velocity
+    easeInQuad: ((t) => t * t),
+    // decelerating to zero velocity
+    easeOutQuad: ((t) => t * (2 - t)),
+    // acceleration until halfway, then deceleration
+    easeInOutQuad: ((t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t)),
+    // accelerating from zero velocity
+    easeInCubic: ((t) => t * t * t),
+    // decelerating to zero velocity
+    easeOutCubic: ((t) => --t * t * t + 1),
+    // acceleration until halfway, then deceleration
+    easeInOutCubic: ((t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1),
+    // accelerating from zero velocity
+    easeInQuart: ((t) => t * t * t * t),
+    // decelerating to zero velocity
+    easeOutQuart: ((t) => 1 - --t * t * t * t),
+    // acceleration until halfway, then deceleration
+    easeInOutQuart: ((t) => t < 0.5 ? 8 * t * t * t * t : 1 - 8 * --t * t * t * t),
+    // accelerating from zero velocity
+    easeInQuint: ((t) => t * t * t * t * t),
+    // decelerating to zero velocity
+    easeOutQuint: ((t) => 1 + --t * t * t * t * t),
+    // acceleration until halfway, then deceleration
+    easeInOutQuint: ((t) => t < 0.5 ? 16 * t * t * t * t * t : 1 + 16 * --t * t * t * t * t),
+    sinBounce: (oscillations) => (t) => (1 - Math.cos(t * oscillations * Math.PI * 2)) / 2,
+    easeInSine: ((t) => -Math.cos(t * (Math.PI / 2)) + 1),
+    easeOutSine: ((t) => Math.sin(t * (Math.PI / 2))),
+    easeInOutSine: ((t) => (-1 / 2) * (Math.cos(Math.PI * t) - 1)),
+    easeInExpo: ((t) => (t === 0 ? 0 : Math.pow(2, 10 * (t - 1)))),
+    easeOutExpo: ((t) => (t === 1 ? 1 : -Math.pow(2, -10 * t) + 1)),
+    easeInOutExpo: ((t) => {
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        if ((t /= 1 / 2) < 1)
+            return (1 / 2) * Math.pow(2, 10 * (t - 1));
+        return (1 / 2) * (-Math.pow(2, -10 * --t) + 2);
+    }),
+    easeInCirc: ((t) => -(Math.sqrt(1 - t * t) - 1)),
+    easeOutCirc: ((t) => Math.sqrt(1 - (t = t - 1) * t)),
+    easeInOutCirc: ((t) => {
+        if (t / 1 / 2 < 1)
+            return (-1 / 2) * (Math.sqrt(1 - t * t) - 1);
+        return (1 / 2) * (Math.sqrt(1 - (t -= 2) * t) + 1);
+    }),
+    easeInElastic: ((t) => {
+        let s = 1.70158;
+        let p = 0;
+        let a = 1;
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        if (!p)
+            p = 0.3;
+        if (a < Math.abs(1)) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
+        }
+        return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p));
+    }),
+    easeOutElastic: ((t) => {
+        let s = 1.70158;
+        let p = 0;
+        let a = 1;
+        if (t === 0)
+            return 0;
+        if (t === 1)
+            return 1;
+        if (!p)
+            p = 0.3;
+        if (a < Math.abs(1)) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
+        }
+        return a * Math.pow(2, -10 * t) * Math.sin(((t - s) * (2 * Math.PI)) / p) + 1;
+    }),
+    easeInOutElastic: ((t) => {
+        let s = 1.70158;
+        let p = 0;
+        let a = 1;
+        if (t === 0)
+            return 0;
+        if (t / 2 === 2)
+            return 1;
+        if (!p)
+            p = 0.3 * 1.5;
+        if (a < 1) {
+            a = 1;
+            s = p / 4;
+        }
+        else {
+            s = (p / (2 * Math.PI)) * Math.asin(1 / a);
+        }
+        if (t < 1)
+            return (-0.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p)));
+        return a * Math.pow(2, -10 * (t -= 1)) * Math.sin(((t - s) * (2 * Math.PI)) / p) * 0.5 + 1;
+    }),
+    easeInBack: (s = 1.70158) => (t) => t * t * ((s + 1) * t - s),
+    easeOutBack: (s = 1.70158) => (t) => (t = t - 1) * t * ((s + 1) * t + s) + 1,
+    easeInOutBack: (s = 1.70158) => (t) => {
+        if ((t /= 1 / 2) < 1)
+            return (1 / 2) * (t * t * (((s *= 1.525) + 1) * t - s));
+        return (1 / 2) * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2);
+    },
+    easeOutBounce: ((t) => {
+        if (t < 1 / 2.75) {
+            return 7.5625 * t * t;
+        }
+        else if (t < 2 / 2.75) {
+            return 7.5625 * (t -= 1.5 / 2.75) * t + 0.75;
+        }
+        else if (t < 2.5 / 2.75) {
+            return 7.5625 * (t -= 2.25 / 2.75) * t + 0.9375;
+        }
+        else {
+            return 7.5625 * (t -= 2.625 / 2.75) * t + 0.984375;
+        }
+    }),
+    makeMirrored: (func) => (t) => {
+        const perceivedT = (t < 0.5 ? t : 1 - t) * 2;
+        return func(perceivedT);
+    },
+    invert: (func) => (t) => {
+        return func(1 - t);
+    },
+};

package/dist/animation/coordinator/Coordinator.d.ts

@@ -1,29 +1,29 @@
-import { Observable } from "@configura/web-utilities";
-import { CfgDeferredMeshNode } from "../../nodes/CfgDeferredMeshNode.js";
-import { CfgProductNode } from "../../nodes/CfgProductNode.js";
-import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
-import { SingleProductView } from "../../view/SingleProductView.js";
-import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
-export declare type CoordinatorCreator = (view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>) => Coordinator;
-export declare type CoordinatorWithMeta = {
-    coordinator: Coordinator;
-    isNewProduct: boolean;
-};
-export declare type CoordinatorConfig = Record<string, unknown>;
-export declare const defaultConfig: CoordinatorConfig;
-export declare abstract class Coordinator<Config extends CoordinatorConfig = CoordinatorConfig> {
-    protected view: SingleProductView;
-    protected phaseObservable: Observable<SingleProductViewPhaseEvent>;
-    protected _config: Config;
-    constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, _config: Config);
-    private phaseListener;
-    destroy(): void;
-    protected productNode: CfgProductNode | undefined;
-    protected setProduct(productNode: CfgProductNode): void;
-    prepareForEnter(_node: CfgSymRootNode, _isNewProduct: boolean): Promise<void>;
-    prepareForExit(_node: CfgSymRootNode): Promise<void>;
-    prepareForMaterialChange(_node: CfgDeferredMeshNode, _isNewProduct: boolean): Promise<void>;
-    abstract willTick(now: number, delta: number): boolean;
-    abstract tick(now: number, delta: number): void;
-}
+import { Observable } from "@configura/web-utilities";
+import { CfgDeferredMeshNode } from "../../nodes/CfgDeferredMeshNode.js";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+import { SingleProductView } from "../../view/SingleProductView.js";
+import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
+export declare type CoordinatorCreator = (view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>) => Coordinator;
+export declare type CoordinatorWithMeta = {
+    coordinator: Coordinator;
+    isNewProduct: boolean;
+};
+export declare type CoordinatorConfig = Record<string, unknown>;
+export declare const defaultConfig: CoordinatorConfig;
+export declare abstract class Coordinator<Config extends CoordinatorConfig = CoordinatorConfig> {
+    protected view: SingleProductView;
+    protected phaseObservable: Observable<SingleProductViewPhaseEvent>;
+    protected _config: Config;
+    constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, _config: Config);
+    private phaseListener;
+    destroy(): void;
+    protected productNode: CfgProductNode | undefined;
+    protected setProduct(productNode: CfgProductNode): void;
+    prepareForEnter(_node: CfgSymRootNode, _isNewProduct: boolean): Promise<void>;
+    prepareForExit(_node: CfgSymRootNode): Promise<void>;
+    prepareForMaterialChange(_node: CfgDeferredMeshNode, _isNewProduct: boolean): Promise<void>;
+    abstract willTick(now: number, delta: number): boolean;
+    abstract tick(now: number, delta: number): void;
+}
 //# sourceMappingURL=Coordinator.d.ts.map

package/dist/animation/coordinator/Coordinator.js

@@ -1,53 +1,53 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { SingleProductViewPhase, } from "../../view/SingleProductViewConfiguration.js";
-export const defaultConfig = {};
-export class Coordinator {
-    constructor(view, phaseObservable, _config) {
-        this.view = view;
-        this.phaseObservable = phaseObservable;
-        this._config = _config;
-        this.phaseListener = (phase) => {
-            const { previous, current } = phase;
-            if (previous !== SingleProductViewPhase.AddNewProduct ||
-                current === SingleProductViewPhase.Error ||
-                current === SingleProductViewPhase.Aborted) {
-                return;
-            }
-            const currentProductNode = this.view.currentProductNode;
-            if (currentProductNode === undefined) {
-                return;
-            }
-            this.setProduct(currentProductNode);
-        };
-        this.phaseObservable.listen(this.phaseListener);
-    }
-    destroy() {
-        this.phaseObservable.stopListen(this.phaseListener);
-    }
-    setProduct(productNode) {
-        this.productNode = productNode;
-    }
-    prepareForEnter(_node, _isNewProduct) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Do nothing
-        });
-    }
-    prepareForExit(_node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Do nothing
-        });
-    }
-    prepareForMaterialChange(_node, _isNewProduct) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Do nothing
-        });
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { SingleProductViewPhase, } from "../../view/SingleProductViewConfiguration.js";
+export const defaultConfig = {};
+export class Coordinator {
+    constructor(view, phaseObservable, _config) {
+        this.view = view;
+        this.phaseObservable = phaseObservable;
+        this._config = _config;
+        this.phaseListener = (phase) => {
+            const { previous, current } = phase;
+            if (previous !== SingleProductViewPhase.AddNewProduct ||
+                current === SingleProductViewPhase.Error ||
+                current === SingleProductViewPhase.Aborted) {
+                return;
+            }
+            const currentProductNode = this.view.currentProductNode;
+            if (currentProductNode === undefined) {
+                return;
+            }
+            this.setProduct(currentProductNode);
+        };
+        this.phaseObservable.listen(this.phaseListener);
+    }
+    destroy() {
+        this.phaseObservable.stopListen(this.phaseListener);
+    }
+    setProduct(productNode) {
+        this.productNode = productNode;
+    }
+    prepareForEnter(_node, _isNewProduct) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Do nothing
+        });
+    }
+    prepareForExit(_node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Do nothing
+        });
+    }
+    prepareForMaterialChange(_node, _isNewProduct) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Do nothing
+        });
+    }
+}

package/dist/animation/coordinator/CoordinatorDropAndSpin.d.ts

@@ -1,23 +1,23 @@
-import { CfgProductNode } from "../../nodes/CfgProductNode.js";
-import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
-import { CoordinatorCreator } from "./Coordinator.js";
-import { CoordinatorNodeQueues, CoordinatorNodeQueuesConfig } from "./CoordinatorNodeQueues.js";
-export declare type CoordinatorDropAndSpinConfig = CoordinatorNodeQueuesConfig & {
-    distance: number;
-    enterDuration: number;
-    exitDuration: number;
-    staggerDuration: number;
-    spinDuration: number;
-};
-export declare const defaultConfig: CoordinatorDropAndSpinConfig;
-export declare class CoordinatorDropAndSpin extends CoordinatorNodeQueues<CoordinatorDropAndSpinConfig> {
-    static getCoordinatorCreator(config?: Partial<CoordinatorDropAndSpinConfig>): CoordinatorCreator;
-    private constructor();
-    destroy(): void;
-    private phaseListenerDropAndSpin;
-    setProduct(productNode: CfgProductNode): void;
-    prepareForEnter(node: CfgSymRootNode, _isNewProduct: boolean): Promise<void>;
-    prepareForExit(node: CfgSymRootNode): Promise<void>;
-    private applyDelay;
-}
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+import { CoordinatorCreator } from "./Coordinator.js";
+import { CoordinatorNodeQueues, CoordinatorNodeQueuesConfig } from "./CoordinatorNodeQueues.js";
+export declare type CoordinatorDropAndSpinConfig = CoordinatorNodeQueuesConfig & {
+    distance: number;
+    enterDuration: number;
+    exitDuration: number;
+    staggerDuration: number;
+    spinDuration: number;
+};
+export declare const defaultConfig: CoordinatorDropAndSpinConfig;
+export declare class CoordinatorDropAndSpin extends CoordinatorNodeQueues<CoordinatorDropAndSpinConfig> {
+    static getCoordinatorCreator(config?: Partial<CoordinatorDropAndSpinConfig>): CoordinatorCreator;
+    private constructor();
+    destroy(): void;
+    private phaseListenerDropAndSpin;
+    setProduct(productNode: CfgProductNode): void;
+    prepareForEnter(node: CfgSymRootNode, _isNewProduct: boolean): Promise<void>;
+    prepareForExit(node: CfgSymRootNode): Promise<void>;
+    private applyDelay;
+}
 //# sourceMappingURL=CoordinatorDropAndSpin.d.ts.map