@configura/babylon-view 1.6.0-iotest.3 → 1.6.0

package/dist/animation/coordinator/CoordinatorDropAndSpin.js

@@ -1,133 +1,138 @@
-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 { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
-import { CfgProductNode } from "../../nodes/CfgProductNode.js";
-import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
-import { SingleProductViewPhase, } from "../../view/SingleProductViewConfiguration.js";
-import { AnimationState } from "../animator/Animator.js";
-import { AnimatorPointToPoint } from "../animator/AnimatorPointToPoint.js";
-import { AnimatorSpin } from "../animator/AnimatorSpin.js";
-import { EasingFunctions } from "../animator/EasingFunctions.js";
-import { CoordinatorNodeQueues, defaultConfig as baseDefaultConfig, } from "./CoordinatorNodeQueues.js";
-export const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { distance: 5, enterDuration: 1000, exitDuration: 500, staggerDuration: 1000, spinDuration: 1500 });
-export class CoordinatorDropAndSpin extends CoordinatorNodeQueues {
-    constructor(view, phaseObservable, config) {
-        super(view, phaseObservable, Object.assign(Object.assign({}, defaultConfig), config));
-        this.phaseListenerDropAndSpin = (phase) => {
-            const { previous, current } = phase;
-            if (previous !== SingleProductViewPhase.ApplyMaterials ||
-                current === SingleProductViewPhase.Error ||
-                current === SingleProductViewPhase.Aborted) {
-                return;
-            }
-            if (this.isFirstRun) {
-                this.applyDelay();
-            }
-            this.run();
-        };
-        this.phaseObservable.listen(this.phaseListenerDropAndSpin);
-    }
-    static getCoordinatorCreator(config) {
-        return (view, phaseObservable) => {
-            return new this(view, phaseObservable, config || {});
-        };
-    }
-    destroy() {
-        super.destroy();
-        this.phaseObservable.stopListen(this.phaseListenerDropAndSpin);
-    }
-    setProduct(productNode) {
-        super.setProduct(productNode);
-        let queue = this.getAnimatorQueue(productNode, true);
-        const animator = new AnimatorSpin(productNode, {
-            translationVector: productNode.boundingBox.center,
-            easing: EasingFunctions.easeInOutQuad,
-            duration: this._config.spinDuration,
-            startPosition: 0,
-            endPosition: Math.PI * 2,
-        }, "spin");
-        queue.add(animator);
-    }
-    prepareForEnter(node, _isNewProduct) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queue = this.getAnimatorQueue(node, true);
-            const adjustToWorldMatrix = node.worldOriginalMatrix.getRotationMatrix().transpose();
-            const animator = new AnimatorPointToPoint(node, {
-                easing: EasingFunctions.easeOutCubic,
-                duration: this._config.enterDuration,
-                startPosition: Vector3.TransformCoordinates(new Vector3(0, this._config.distance, 0), adjustToWorldMatrix),
-            }, "enter");
-            animator.apply0();
-            queue.add(animator);
-        });
-    }
-    prepareForExit(node) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const queue = this.getAnimatorQueue(node);
-            if (queue === undefined) {
-                return;
-            }
-            const adjustToWorldMatrix = node.worldOriginalMatrix.getRotationMatrix().transpose();
-            const animator = new AnimatorPointToPoint(node, {
-                easing: EasingFunctions.easeInCubic,
-                duration: this._config.exitDuration,
-                endPosition: Vector3.TransformCoordinates(new Vector3(0, -this._config.distance, 0), adjustToWorldMatrix),
-            }, "exit");
-            queue.add(animator);
-            yield new Promise((resolve) => {
-                const isDone = () => {
-                    this.removeAnimatorQueue(queue);
-                    resolve();
-                    queue.stopListenForDone(isDone);
-                };
-                queue.listenForDone(isDone);
-            });
-        });
-    }
-    applyDelay() {
-        //So that they fall in in order by z
-        const queuesWithDelay = this.animationQueues
-            .filter((q) => {
-            if (!(q.node instanceof CfgSymRootNode)) {
-                return false;
-            }
-            const top = q.peek();
-            if (top === undefined) {
-                return false;
-            }
-            return top.type === "enter" && top.state === AnimationState.Ready;
-        })
-            .map((q) => ({
-            q,
-            bb: q.node.boundingBox.clone().applyMatrix(q.node.worldOriginalMatrix),
-        }));
-        queuesWithDelay.sort((left, right) => {
-            return left.bb.minimum.y < right.bb.minimum.y ? -1 : 1;
-        });
-        let delayCounter = 0;
-        for (const animationQueue of queuesWithDelay) {
-            const top = animationQueue.q.peek();
-            if (top === undefined) {
-                continue;
-            }
-            top.delay = delayCounter;
-            delayCounter += this._config.staggerDuration;
-        }
-        const productQueue = this.animationQueues.find((q) => {
-            return q.node instanceof CfgProductNode;
-        });
-        if (productQueue) {
-            const topProductAnimation = productQueue.peek();
-            if (topProductAnimation && topProductAnimation.state === AnimationState.Ready) {
-                topProductAnimation.delay = delayCounter;
-            }
-        }
-    }
-}
+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 { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { CfgProductNode } from "../../nodes/CfgProductNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+import { SingleProductViewPhase, } from "../../view/SingleProductViewConfiguration.js";
+import { AnimationState } from "../animator/Animator.js";
+import { AnimatorPointToPoint } from "../animator/AnimatorPointToPoint.js";
+import { AnimatorSpin } from "../animator/AnimatorSpin.js";
+import { EasingFunctions } from "../animator/EasingFunctions.js";
+import { CoordinatorNodeQueues, defaultConfig as baseDefaultConfig, } from "./CoordinatorNodeQueues.js";
+export const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { distance: 5, enterDuration: 1000, exitDuration: 500, staggerDuration: 1000, spinDuration: 1500 });
+export class CoordinatorDropAndSpin extends CoordinatorNodeQueues {
+    constructor(view, phaseObservable, config) {
+        super(view, phaseObservable, Object.assign(Object.assign({}, defaultConfig), config));
+        this.phaseListenerDropAndSpin = (phase) => {
+            const { previous, current } = phase;
+            if (previous !== SingleProductViewPhase.ApplyMaterials ||
+                current === SingleProductViewPhase.Error ||
+                current === SingleProductViewPhase.Aborted) {
+                return;
+            }
+            if (this.isFirstRun) {
+                this.applyDelay();
+            }
+            this.run();
+        };
+        this.phaseObservable.listen(this.phaseListenerDropAndSpin);
+    }
+    static getCoordinatorCreator(config) {
+        return (view, phaseObservable) => {
+            return new this(view, phaseObservable, config || {});
+        };
+    }
+    destroy() {
+        super.destroy();
+        this.phaseObservable.stopListen(this.phaseListenerDropAndSpin);
+    }
+    setProduct(productNode) {
+        super.setProduct(productNode);
+        const queue = this.getAnimatorQueue(productNode, true);
+        if (queue === undefined) {
+            throw new Error("No queue unexpected");
+        }
+        const animator = new AnimatorSpin(productNode, {
+            translationVector: productNode.boundingBox.center,
+            easing: EasingFunctions.easeInOutQuad,
+            duration: this._config.spinDuration,
+            startPosition: 0,
+            endPosition: Math.PI * 2,
+        }, "spin");
+        queue.add(animator);
+    }
+    prepareForEnter(node, _isNewProduct) {
+        const queue = this.getAnimatorQueue(node, true);
+        if (queue === undefined) {
+            throw new Error("No queue unexpected");
+        }
+        const adjustToWorldMatrix = node.worldOriginalMatrix.getRotationMatrix().transpose();
+        const animator = new AnimatorPointToPoint(node, {
+            easing: EasingFunctions.easeOutCubic,
+            duration: this._config.enterDuration,
+            startPosition: Vector3.TransformCoordinates(new Vector3(0, this._config.distance, 0), adjustToWorldMatrix),
+        }, "enter");
+        animator.apply0();
+        queue.add(animator);
+        return Promise.resolve();
+    }
+    prepareForExit(node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = this.getAnimatorQueue(node);
+            if (queue === undefined) {
+                return;
+            }
+            const adjustToWorldMatrix = node.worldOriginalMatrix.getRotationMatrix().transpose();
+            const animator = new AnimatorPointToPoint(node, {
+                easing: EasingFunctions.easeInCubic,
+                duration: this._config.exitDuration,
+                endPosition: Vector3.TransformCoordinates(new Vector3(0, -this._config.distance, 0), adjustToWorldMatrix),
+            }, "exit");
+            queue.add(animator);
+            yield new Promise((resolve) => {
+                const isDone = () => {
+                    this.removeAnimatorQueue(queue);
+                    resolve();
+                    queue.stopListenForDone(isDone);
+                };
+                queue.listenForDone(isDone);
+            });
+        });
+    }
+    applyDelay() {
+        //So that they fall in in order by z
+        const queuesWithDelay = this.animationQueues
+            .filter((q) => {
+            if (!(q.node instanceof CfgSymRootNode)) {
+                return false;
+            }
+            const top = q.peek();
+            if (top === undefined) {
+                return false;
+            }
+            return top.type === "enter" && top.state === AnimationState.Ready;
+        })
+            .map((q) => ({
+            q,
+            bb: q.node.boundingBox.clone().applyMatrix(q.node.worldOriginalMatrix),
+        }));
+        queuesWithDelay.sort((left, right) => {
+            return left.bb.minimum.y < right.bb.minimum.y ? -1 : 1;
+        });
+        let delayCounter = 0;
+        for (const animationQueue of queuesWithDelay) {
+            const top = animationQueue.q.peek();
+            if (top === undefined) {
+                continue;
+            }
+            top.delay = delayCounter;
+            delayCounter += this._config.staggerDuration;
+        }
+        const productQueue = this.animationQueues.find((q) => {
+            return q.node instanceof CfgProductNode;
+        });
+        if (productQueue) {
+            const topProductAnimation = productQueue.peek();
+            if (topProductAnimation && topProductAnimation.state === AnimationState.Ready) {
+                topProductAnimation.delay = delayCounter;
+            }
+        }
+    }
+}

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

@@ -1,12 +1,12 @@
-import { Observable } from "@configura/web-utilities";
-import { SingleProductView } from "../../view/SingleProductView.js";
-import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
-import { Coordinator } from "./Coordinator.js";
-export declare class CoordinatorIdentity extends Coordinator<{}> {
-    protected view: SingleProductView;
-    protected phaseObservable: Observable<SingleProductViewPhaseEvent>;
-    constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>);
-    willTick(_now: number, _delta: number): boolean;
-    tick(_now: number, _delta: number): void;
-}
+import { Observable } from "@configura/web-utilities";
+import { SingleProductView } from "../../view/SingleProductView.js";
+import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
+import { Coordinator } from "./Coordinator.js";
+export declare class CoordinatorIdentity extends Coordinator<Record<string, unknown>> {
+    protected view: SingleProductView;
+    protected phaseObservable: Observable<SingleProductViewPhaseEvent>;
+    constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>);
+    willTick(_now: number, _delta: number): boolean;
+    tick(_now: number, _delta: number): void;
+}
 //# sourceMappingURL=CoordinatorIdentity.d.ts.map

package/dist/animation/coordinator/CoordinatorIdentity.js

@@ -1,12 +1,14 @@
-import { Coordinator, defaultConfig as baseDefaultConfig } from "./Coordinator.js";
-export class CoordinatorIdentity extends Coordinator {
-    constructor(view, phaseObservable) {
-        super(view, phaseObservable, baseDefaultConfig);
-        this.view = view;
-        this.phaseObservable = phaseObservable;
-    }
-    willTick(_now, _delta) {
-        return false;
-    }
-    tick(_now, _delta) { }
-}
+import { Coordinator, defaultConfig as baseDefaultConfig } from "./Coordinator.js";
+export class CoordinatorIdentity extends Coordinator {
+    constructor(view, phaseObservable) {
+        super(view, phaseObservable, baseDefaultConfig);
+        this.view = view;
+        this.phaseObservable = phaseObservable;
+    }
+    willTick(_now, _delta) {
+        return false;
+    }
+    tick(_now, _delta) {
+        // Do nothing
+    }
+}

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

@@ -1,19 +1,19 @@
-import { Observable } from "@configura/web-utilities";
-import { SingleProductView } from "../../view/SingleProductView.js";
-import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { AnimatorQueue } from "../animator/AnimatorQueue.js";
-import { Coordinator, CoordinatorConfig } from "./Coordinator.js";
-export declare type CoordinatorNodeQueuesConfig = CoordinatorConfig & {};
-export declare const defaultConfig: CoordinatorNodeQueuesConfig;
-export declare abstract class CoordinatorNodeQueues<Config extends CoordinatorNodeQueuesConfig> extends Coordinator<Config> {
-    protected animationQueues: AnimatorQueue[];
-    protected isFirstRun: boolean;
-    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Config);
-    getAnimatorQueue(node: AnimatableObject, orCreate?: boolean): AnimatorQueue | undefined;
-    removeAnimatorQueue(queue: AnimatorQueue): void;
-    protected run(): false | undefined;
-    willTick(now: number, delta: number): boolean;
-    tick(now: number, delta: number): void;
-}
+import { Observable } from "@configura/web-utilities";
+import { SingleProductView } from "../../view/SingleProductView.js";
+import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { AnimatorQueue } from "../animator/AnimatorQueue.js";
+import { Coordinator, CoordinatorConfig } from "./Coordinator.js";
+export declare type CoordinatorNodeQueuesConfig = CoordinatorConfig;
+export declare const defaultConfig: CoordinatorNodeQueuesConfig;
+export declare abstract class CoordinatorNodeQueues<Config extends CoordinatorNodeQueuesConfig> extends Coordinator<Config> {
+    protected animationQueues: AnimatorQueue[];
+    protected isFirstRun: boolean;
+    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Config);
+    getAnimatorQueue(node: AnimatableObject, orCreate?: boolean): AnimatorQueue | undefined;
+    removeAnimatorQueue(queue: AnimatorQueue): void;
+    protected run(): void;
+    willTick(now: number, delta: number): boolean;
+    tick(now: number, delta: number): void;
+}
 //# sourceMappingURL=CoordinatorNodeQueues.d.ts.map

package/dist/animation/coordinator/CoordinatorNodeQueues.js

@@ -1,50 +1,50 @@
-import { AnimatorQueue } from "../animator/AnimatorQueue.js";
-import { Coordinator, defaultConfig as baseDefaultConfig, } from "./Coordinator.js";
-export const defaultConfig = Object.assign({}, baseDefaultConfig);
-export class CoordinatorNodeQueues extends Coordinator {
-    constructor(view, phaseObservable, config) {
-        super(view, phaseObservable, config);
-        this.animationQueues = [];
-        this.isFirstRun = true;
-    }
-    getAnimatorQueue(node, orCreate = false) {
-        let queue = this.animationQueues.find((queue) => queue.node === node);
-        if (queue === undefined && orCreate) {
-            queue = new AnimatorQueue(node);
-            this.animationQueues.push(queue);
-        }
-        return queue;
-    }
-    removeAnimatorQueue(queue) {
-        const index = this.animationQueues.indexOf(queue);
-        if (index < 0) {
-            return;
-        }
-        this.animationQueues.splice(index, 1);
-    }
-    run() {
-        if (this.productNode === undefined) {
-            return false;
-        }
-        if (this.isFirstRun) {
-            this.isFirstRun = false;
-        }
-        this.animationQueues.forEach((o) => {
-            o.run();
-        });
-    }
-    willTick(now, delta) {
-        let someWillTick = false;
-        for (const o of this.animationQueues) {
-            if (o.willTick(now, delta)) {
-                someWillTick = true;
-            }
-        }
-        return someWillTick;
-    }
-    tick(now, delta) {
-        for (const o of this.animationQueues) {
-            o.tick(now, delta);
-        }
-    }
-}
+import { AnimatorQueue } from "../animator/AnimatorQueue.js";
+import { Coordinator, defaultConfig as baseDefaultConfig, } from "./Coordinator.js";
+export const defaultConfig = Object.assign({}, baseDefaultConfig);
+export class CoordinatorNodeQueues extends Coordinator {
+    constructor(view, phaseObservable, config) {
+        super(view, phaseObservable, config);
+        this.animationQueues = [];
+        this.isFirstRun = true;
+    }
+    getAnimatorQueue(node, orCreate = false) {
+        let queue = this.animationQueues.find((queue) => queue.node === node);
+        if (queue === undefined && orCreate) {
+            queue = new AnimatorQueue(node);
+            this.animationQueues.push(queue);
+        }
+        return queue;
+    }
+    removeAnimatorQueue(queue) {
+        const index = this.animationQueues.indexOf(queue);
+        if (index < 0) {
+            return;
+        }
+        this.animationQueues.splice(index, 1);
+    }
+    run() {
+        if (this.productNode === undefined) {
+            return;
+        }
+        if (this.isFirstRun) {
+            this.isFirstRun = false;
+        }
+        this.animationQueues.forEach((o) => {
+            o.run();
+        });
+    }
+    willTick(now, delta) {
+        let someWillTick = false;
+        for (const o of this.animationQueues) {
+            if (o.willTick(now, delta)) {
+                someWillTick = true;
+            }
+        }
+        return someWillTick;
+    }
+    tick(now, delta) {
+        for (const o of this.animationQueues) {
+            o.tick(now, delta);
+        }
+    }
+}

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

@@ -1,22 +1,22 @@
-import { Observable } from "@configura/web-utilities";
-import { CfgDeferredMeshNode } from "../../nodes/CfgDeferredMeshNode.js";
-import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
-import { SingleProductView } from "../../view/SingleProductView.js";
-import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { CoordinatorNodeQueues, CoordinatorNodeQueuesConfig } from "./CoordinatorNodeQueues.js";
-export declare type CoordinatorPulseConfig = CoordinatorNodeQueuesConfig & {
-    duration: number;
-    delay: number;
-    doForNewProducts: boolean;
-};
-export declare const defaultConfig: CoordinatorPulseConfig;
-export declare abstract class CoordinatorPulse<Config extends CoordinatorPulseConfig> extends CoordinatorNodeQueues<Config> {
-    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Config);
-    destroy(): void;
-    private phaseListenerPulse;
-    protected abstract _prepare(node: AnimatableObject, isNewProduct: boolean): Promise<void>;
-    prepareForEnter(node: CfgSymRootNode, isNewProduct: boolean): Promise<void>;
-    prepareForMaterialChange(node: CfgDeferredMeshNode, isNewProduct: boolean): Promise<void>;
-}
+import { Observable } from "@configura/web-utilities";
+import { CfgDeferredMeshNode } from "../../nodes/CfgDeferredMeshNode.js";
+import { CfgSymRootNode } from "../../nodes/CfgSymRootNode.js";
+import { SingleProductView } from "../../view/SingleProductView.js";
+import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { CoordinatorNodeQueues, CoordinatorNodeQueuesConfig } from "./CoordinatorNodeQueues.js";
+export declare type CoordinatorPulseConfig = CoordinatorNodeQueuesConfig & {
+    duration: number;
+    delay: number;
+    doForNewProducts: boolean;
+};
+export declare const defaultConfig: CoordinatorPulseConfig;
+export declare abstract class CoordinatorPulse<Config extends CoordinatorPulseConfig> extends CoordinatorNodeQueues<Config> {
+    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Config);
+    destroy(): void;
+    private phaseListenerPulse;
+    protected abstract _prepare(node: AnimatableObject, isNewProduct: boolean): Promise<void>;
+    prepareForEnter(node: CfgSymRootNode, isNewProduct: boolean): Promise<void>;
+    prepareForMaterialChange(node: CfgDeferredMeshNode, isNewProduct: boolean): Promise<void>;
+}
 //# sourceMappingURL=CoordinatorPulse.d.ts.map

package/dist/animation/coordinator/CoordinatorPulse.js

@@ -1,47 +1,47 @@
-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";
-import { CoordinatorNodeQueues, defaultConfig as baseDefaultConfig, } from "./CoordinatorNodeQueues.js";
-export const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { duration: 1000, delay: 50, doForNewProducts: false });
-export class CoordinatorPulse extends CoordinatorNodeQueues {
-    constructor(view, phaseObservable, config) {
-        super(view, phaseObservable, config);
-        this.phaseListenerPulse = (phase) => {
-            const { previous, current } = phase;
-            if (previous !== SingleProductViewPhase.AppliedMaterials ||
-                current === SingleProductViewPhase.Error ||
-                current === SingleProductViewPhase.Aborted) {
-                return;
-            }
-            this.run();
-        };
-        this.phaseObservable.listen(this.phaseListenerPulse);
-    }
-    destroy() {
-        super.destroy();
-        this.phaseObservable.stopListen(this.phaseListenerPulse);
-    }
-    prepareForEnter(node, isNewProduct) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._config.doForNewProducts && isNewProduct) {
-                return;
-            }
-            yield this._prepare(node, isNewProduct);
-        });
-    }
-    prepareForMaterialChange(node, isNewProduct) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isNewProduct) {
-                return;
-            }
-            yield this._prepare(node, isNewProduct);
-        });
-    }
-}
+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";
+import { CoordinatorNodeQueues, defaultConfig as baseDefaultConfig, } from "./CoordinatorNodeQueues.js";
+export const defaultConfig = Object.assign(Object.assign({}, baseDefaultConfig), { duration: 1000, delay: 50, doForNewProducts: false });
+export class CoordinatorPulse extends CoordinatorNodeQueues {
+    constructor(view, phaseObservable, config) {
+        super(view, phaseObservable, config);
+        this.phaseListenerPulse = (phase) => {
+            const { previous, current } = phase;
+            if (previous !== SingleProductViewPhase.AppliedMaterials ||
+                current === SingleProductViewPhase.Error ||
+                current === SingleProductViewPhase.Aborted) {
+                return;
+            }
+            this.run();
+        };
+        this.phaseObservable.listen(this.phaseListenerPulse);
+    }
+    destroy() {
+        super.destroy();
+        this.phaseObservable.stopListen(this.phaseListenerPulse);
+    }
+    prepareForEnter(node, isNewProduct) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._config.doForNewProducts && isNewProduct) {
+                return;
+            }
+            yield this._prepare(node, isNewProduct);
+        });
+    }
+    prepareForMaterialChange(node, isNewProduct) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isNewProduct) {
+                return;
+            }
+            yield this._prepare(node, isNewProduct);
+        });
+    }
+}

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

@@ -1,15 +1,15 @@
-import { Observable } from "@configura/web-utilities";
-import { SingleProductView } from "../../view/SingleProductView.js";
-import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
-import { AnimatableObject } from "../AnimatableObject.js";
-import { CoordinatorCreator } from "./Coordinator.js";
-import { CoordinatorPulse, CoordinatorPulseConfig } from "./CoordinatorPulse.js";
-export declare type CoordinatorPulseBounceConfig = CoordinatorPulseConfig & {
-    height: number;
-};
-export declare class CoordinatorPulseBounce extends CoordinatorPulse<CoordinatorPulseBounceConfig> {
-    static getCoordinatorCreator(config?: Partial<CoordinatorPulseBounceConfig>): CoordinatorCreator;
-    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Partial<CoordinatorPulseBounceConfig>);
-    _prepare(node: AnimatableObject, _isNewProduct: boolean): Promise<void>;
-}
+import { Observable } from "@configura/web-utilities";
+import { SingleProductView } from "../../view/SingleProductView.js";
+import { SingleProductViewPhaseEvent } from "../../view/SingleProductViewConfiguration.js";
+import { AnimatableObject } from "../AnimatableObject.js";
+import { CoordinatorCreator } from "./Coordinator.js";
+import { CoordinatorPulse, CoordinatorPulseConfig } from "./CoordinatorPulse.js";
+export declare type CoordinatorPulseBounceConfig = CoordinatorPulseConfig & {
+    height: number;
+};
+export declare class CoordinatorPulseBounce extends CoordinatorPulse<CoordinatorPulseBounceConfig> {
+    static getCoordinatorCreator(config?: Partial<CoordinatorPulseBounceConfig>): CoordinatorCreator;
+    protected constructor(view: SingleProductView, phaseObservable: Observable<SingleProductViewPhaseEvent>, config: Partial<CoordinatorPulseBounceConfig>);
+    _prepare(node: AnimatableObject, _isNewProduct: boolean): Promise<void>;
+}
 //# sourceMappingURL=CoordinatorPulseBounce.d.ts.map