@wolsok/thanos 3.0.1 → 16.0.0

package/esm2022/lib/ws-thanos.service.mjs

@@ -0,0 +1,257 @@
+import { Inject, Injectable, NgZone } from '@angular/core';
+import { default as html2canvas } from 'html2canvas';
+import { animationFrameScheduler, from, interval, map, switchMap, takeWhile, tap, timeInterval, } from 'rxjs';
+import { SimplexNoise } from './simplex-noise';
+import { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';
+import * as i0 from "@angular/core";
+const PARTICLE_BYTE_LENGTH = 10;
+const MIN_PARTICLE_ALPHA = ~~(255 * 0.01);
+const HEIGHT_SCALE = 5;
+const WIDTH_SCALE = 2;
+const FLOW_FIELD_RES = 0.05;
+class WsThanosService {
+    thanosOptions;
+    ngZone;
+    constructor(thanosOptions, ngZone) {
+        this.thanosOptions = thanosOptions;
+        this.ngZone = ngZone;
+    }
+    static getParticleIndicesForBase(base) {
+        return {
+            x: base,
+            y: base + 1,
+            dx: base + 2,
+            dy: base + 3,
+            ax: base + 4,
+            ay: base + 5,
+            r: base + 6,
+            g: base + 7,
+            b: base + 8,
+            a: base + 9,
+        };
+    }
+    static getColorIndicesForCoord(x, y, width) {
+        const red = y * (width * 4) + x * 4;
+        return { r: red, g: red + 1, b: red + 2, a: red + 3 };
+    }
+    static updateParticles({ seed, noise, particlesData, thanosOptions, animationState, }) {
+        const { deltaTSec, animationT, maxWidth, maxHeight } = animationState;
+        const { particleAcceleration } = thanosOptions;
+        const { particles, maxParticleX, minParticleY } = particlesData;
+        // the time is used to calculate the vaporization front.
+        const time = Math.sin(animationT * (Math.PI / 2)) * 1.1;
+        const startAccelerateX = maxParticleX - time * maxParticleX;
+        const startAccelerateY = time * (maxHeight - minParticleY) + minParticleY;
+        const lengthY = maxHeight - startAccelerateY;
+        const accelerateRadiusPow = startAccelerateX * startAccelerateX + lengthY * lengthY;
+        for (let i = 0; i < particles.length; i += PARTICLE_BYTE_LENGTH) {
+            const { x, y, dx, dy, ax, ay, a } = WsThanosService.getParticleIndicesForBase(i);
+            const particleX = particles[x];
+            const particleY = particles[y];
+            // only update particles that are inside view and visible
+            if (particleX > maxWidth ||
+                particleX < 0 ||
+                particleY > maxHeight ||
+                particleY < 0 ||
+                particles[a] < MIN_PARTICLE_ALPHA) {
+                continue;
+            }
+            if (!(Math.abs(particles[ax]) > 0 || Math.abs(particles[ay]) > 0)) {
+                let pYLength = maxHeight - particleY;
+                let pXLength = particleX;
+                // we calculate some random looking numbers and functions to have nice looking vaporizing front of particles
+                // todo consider to use noise;
+                pXLength += Math.tan((pXLength / 20.12) * time + seed) * 0.5;
+                pXLength += (particleX % deltaTSec) * 0.5;
+                pXLength += Math.sin((pXLength / 30 + 723.394) * time + seed * 12.5) * 11;
+                pYLength += Math.tan((pYLength / 0.45) * time + seed * 1.5) * 0.5;
+                pYLength += Math.cos((pYLength / 100 + 2323.234) * time + seed * 456.1) * 23;
+                const pLength = pXLength * pXLength + pYLength * pYLength;
+                if (pLength > accelerateRadiusPow) {
+                    particles[ax] = Math.random();
+                    particles[ay] = Math.random() * -1;
+                }
+            }
+            else {
+                // use noise to flow along velocity field
+                const flowFieldAcc = WsThanosService.getXYFromFlowField(noise, seed, particleX, particleY);
+                const accelerationX = flowFieldAcc[0];
+                const accelerationY = flowFieldAcc[1];
+                particles[ax] += accelerationX;
+                particles[ay] += accelerationY;
+            }
+            // * Math.pow(1 + animationT, 4)
+            particles[dx] += particles[ax] * particleAcceleration * deltaTSec;
+            particles[dy] += particles[ay] * particleAcceleration * deltaTSec;
+            particles[x] += particles[dx] * deltaTSec;
+            particles[y] += particles[dy] * deltaTSec;
+            // fade particle out ( very late);
+            particles[a] *= 1 - Math.pow(animationT, 15); // 255 - Math.sqrt(particles[dx] * particles[dx] + particles[dy] * particles[dy]) / 1.2;
+        }
+    }
+    static drawParticles(drawCtx, particles) {
+        const { width, height } = drawCtx.canvas;
+        drawCtx.clearRect(0, 0, width, height);
+        const image = drawCtx.getImageData(0, 0, width, height);
+        const imageData = image.data;
+        for (let i = 0; i < particles.length; i += PARTICLE_BYTE_LENGTH) {
+            const particleX = particles[i];
+            const particleY = particles[i + 1];
+            const pI = WsThanosService.getParticleIndicesForBase(i);
+            if (particleX > width ||
+                particleX < 0 ||
+                particleY > height ||
+                particleY < 0 ||
+                particles[pI.a] < MIN_PARTICLE_ALPHA) {
+                continue;
+            }
+            const { r, g, b, a } = WsThanosService.getColorIndicesForCoord(~~particles[pI.x], ~~particles[pI.y], width);
+            imageData[r] = ~~particles[pI.r];
+            imageData[g] = ~~particles[pI.g];
+            imageData[b] = ~~particles[pI.b];
+            imageData[a] = ~~particles[pI.a];
+        }
+        drawCtx.putImageData(image, 0, 0);
+    }
+    static prepareCanvasForVaporize(divCanvas, maxParticleCount) {
+        const { width, height } = divCanvas;
+        // scale result canvas to have more room to draw particles while vaporizing;
+        const resultHeight = height * HEIGHT_SCALE;
+        const resultWidth = width * WIDTH_SCALE;
+        const resultCanvas = document.createElement('canvas');
+        resultCanvas.height = resultHeight;
+        resultCanvas.width = resultWidth;
+        const imageData = divCanvas.getContext('2d')?.getImageData(0, 0, width, height);
+        if (imageData == null) {
+            throw new Error('Could not get image data from canvas');
+        }
+        const particlesData = WsThanosService.createParticlesForImageData(imageData, maxParticleCount, resultHeight);
+        return { resultCanvas, particlesData };
+    }
+    static createParticlesForImageData(imageData, maxParticleCount, resultHeight) {
+        const { width, height } = imageData;
+        let particleCandidates = 0;
+        let particleCount = 0;
+        const particleCandiatesList = [];
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const { a } = WsThanosService.getColorIndicesForCoord(x, y, width);
+                if (imageData.data[a] >= MIN_PARTICLE_ALPHA) {
+                    particleCandidates++;
+                    particleCandiatesList.push({ x, y });
+                }
+            }
+        }
+        const maxNumParticles = Math.min(particleCandidates, maxParticleCount);
+        const particles = new Float32Array(Float32Array.BYTES_PER_ELEMENT * maxNumParticles * PARTICLE_BYTE_LENGTH);
+        let maxParticleX = 0;
+        let minParticleY = resultHeight;
+        while (particleCount < maxNumParticles) {
+            // select random index from candiates
+            const index = ~~(Math.random() * particleCandiatesList.length);
+            const { x, y } = particleCandiatesList[index];
+            // overwrite index with last element to prevent double selection of particles
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            particleCandiatesList[index] = particleCandiatesList.pop();
+            maxParticleX = Math.max(maxParticleX, x);
+            minParticleY = Math.min(minParticleY, y);
+            const { dx, dy, ax, ay, r, g, b, a, ...xy } = WsThanosService.getParticleIndicesForBase(particleCount * PARTICLE_BYTE_LENGTH);
+            particles[xy.x] = x;
+            particles[xy.y] = y + resultHeight - height;
+            particles[dx] = 0;
+            particles[dy] = 0;
+            particles[ax] = 0;
+            particles[ay] = 0;
+            const indicesImage = WsThanosService.getColorIndicesForCoord(x, y, width);
+            particles[r] = imageData.data[indicesImage.r];
+            particles[g] = imageData.data[indicesImage.g];
+            particles[b] = imageData.data[indicesImage.b];
+            particles[a] = imageData.data[indicesImage.a];
+            particleCount++;
+        }
+        return { particles, maxParticleX, minParticleY };
+    }
+    static getXYFromFlowField(noise, seed, x, y) {
+        const sampleX = noise.scaled3D(x, y, seed + 33.23, FLOW_FIELD_RES);
+        const sampleY = noise.scaled3D(x, seed / 13.23, y, FLOW_FIELD_RES) * -1;
+        return [sampleX, sampleY];
+    }
+    /**
+     * start the vaporize-effect.
+     *
+     * It's running outside the ngZone.
+     */
+    vaporize(elem) {
+        return this.ngZone.runOutsideAngular(() => this.vaporizeIntern(elem));
+    }
+    vaporizeIntern(elem) {
+        elem.style.opacity = elem.style.opacity || '1';
+        elem.style.transition = `opacity ${Math.floor(this.thanosOptions.animationLength * 0.8)}ms ease-out`;
+        const noise = new SimplexNoise({ frequency: 0.01, min: 0 });
+        const seed = new Date().getDate() * Math.random();
+        const html2CanvasPromise = html2canvas(elem, {
+            backgroundColor: null,
+            scale: 1,
+            allowTaint: true,
+            windowHeight: window.innerHeight,
+            windowWidth: window.innerWidth,
+            scrollY: -window.scrollY,
+        });
+        return from(html2CanvasPromise).pipe(map((canvasFromHtmlElem) => {
+            const canvasAndParticles = WsThanosService.prepareCanvasForVaporize(canvasFromHtmlElem, this.thanosOptions.maxParticleCount);
+            const { resultCanvas } = canvasAndParticles;
+            if (elem.parentElement) {
+                elem.parentElement.style.position = elem.parentElement.style.position || 'relative';
+            }
+            resultCanvas.style.position = 'absolute';
+            resultCanvas.style.left = 0 + 'px';
+            resultCanvas.style.top = '-' + elem.getBoundingClientRect().height * (HEIGHT_SCALE - 1) + 'px';
+            resultCanvas.style.zIndex = '2000';
+            resultCanvas.style.pointerEvents = 'none';
+            elem.insertAdjacentElement('beforebegin', resultCanvas);
+            // this should start the transition above defined
+            elem.style.opacity = '0';
+            return canvasAndParticles;
+        }), switchMap(({ resultCanvas, particlesData }) => {
+            let time = 0;
+            const { animationLength, maxParticleCount, particleAcceleration } = this.thanosOptions;
+            return interval(1000 / 60, animationFrameScheduler).pipe(timeInterval(), tap((deltaT) => (time += deltaT.interval)), map((deltaT) => ({
+                deltaTSec: deltaT.interval / 1000,
+                animationT: time / animationLength,
+                maxWidth: resultCanvas.width,
+                maxHeight: resultCanvas.height,
+            })), tap((animationState) => {
+                WsThanosService.updateParticles({
+                    particlesData,
+                    animationState,
+                    thanosOptions: {
+                        animationLength,
+                        maxParticleCount,
+                        particleAcceleration,
+                    },
+                    noise,
+                    seed,
+                });
+                const context = resultCanvas.getContext('2d');
+                if (context) {
+                    WsThanosService.drawParticles(context, particlesData.particles);
+                }
+            }), takeWhile((animationState) => animationState.animationT <= 1), tap({
+                complete: () => {
+                    return resultCanvas.remove();
+                },
+            }));
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsThanosService, deps: [{ token: WS_THANOS_OPTIONS_TOKEN }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsThanosService, providedIn: 'root' });
+}
+export { WsThanosService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsThanosService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WS_THANOS_OPTIONS_TOKEN]
+                }] }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ws-thanos.service.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/ws-thanos.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, NgZone } from '@angular/core';\n\nimport { default as html2canvas } from 'html2canvas';\nimport {\n  animationFrameScheduler,\n  from,\n  interval,\n  map,\n  Observable,\n  switchMap,\n  takeWhile,\n  tap,\n  timeInterval,\n} from 'rxjs';\nimport { SimplexNoise } from './simplex-noise';\nimport { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';\nimport type { WsThanosOptions } from './ws-thanos.options';\n\nconst PARTICLE_BYTE_LENGTH = 10;\nconst MIN_PARTICLE_ALPHA = ~~(255 * 0.01);\nconst HEIGHT_SCALE = 5;\nconst WIDTH_SCALE = 2;\nconst FLOW_FIELD_RES = 0.05;\n\ninterface ParticlesData {\n  particles: Float32Array;\n  maxParticleX: number;\n  minParticleY: number;\n}\n\ninterface AnimationState {\n  deltaTSec: number;\n  animationT: number;\n  maxWidth: number;\n  maxHeight: number;\n}\n\ninterface UpdateParticleParams {\n  particlesData: ParticlesData;\n  animationState: AnimationState;\n  thanosOptions: WsThanosOptions;\n  noise: SimplexNoise;\n  seed: number;\n}\n\ninterface ParticleIndices {\n  x: number;\n  y: number;\n  dx: number;\n  dy: number;\n  ax: number;\n  ay: number;\n  r: number;\n  g: number;\n  b: number;\n  a: number;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class WsThanosService {\n  constructor(\n    @Inject(WS_THANOS_OPTIONS_TOKEN)\n    private thanosOptions: WsThanosOptions,\n    private ngZone: NgZone\n  ) {}\n\n  private static getParticleIndicesForBase(base: number): ParticleIndices {\n    return {\n      x: base,\n      y: base + 1,\n      dx: base + 2,\n      dy: base + 3,\n      ax: base + 4,\n      ay: base + 5,\n      r: base + 6,\n      g: base + 7,\n      b: base + 8,\n      a: base + 9,\n    };\n  }\n\n  private static getColorIndicesForCoord(\n    x: number,\n    y: number,\n    width: number\n  ): { a: number; r: number; b: number; g: number } {\n    const red = y * (width * 4) + x * 4;\n    return { r: red, g: red + 1, b: red + 2, a: red + 3 };\n  }\n\n  private static updateParticles({\n    seed,\n    noise,\n    particlesData,\n    thanosOptions,\n    animationState,\n  }: UpdateParticleParams): void {\n    const { deltaTSec, animationT, maxWidth, maxHeight } = animationState;\n    const { particleAcceleration } = thanosOptions;\n    const { particles, maxParticleX, minParticleY } = particlesData;\n\n    // the time is used to calculate the vaporization front.\n    const time = Math.sin(animationT * (Math.PI / 2)) * 1.1;\n\n    const startAccelerateX = maxParticleX - time * maxParticleX;\n    const startAccelerateY = time * (maxHeight - minParticleY) + minParticleY;\n\n    const lengthY = maxHeight - startAccelerateY;\n    const accelerateRadiusPow = startAccelerateX * startAccelerateX + lengthY * lengthY;\n\n    for (let i = 0; i < particles.length; i += PARTICLE_BYTE_LENGTH) {\n      const { x, y, dx, dy, ax, ay, a } = WsThanosService.getParticleIndicesForBase(i);\n      const particleX = particles[x];\n      const particleY = particles[y];\n\n      // only update particles that are inside view and visible\n      if (\n        particleX > maxWidth ||\n        particleX < 0 ||\n        particleY > maxHeight ||\n        particleY < 0 ||\n        particles[a] < MIN_PARTICLE_ALPHA\n      ) {\n        continue;\n      }\n\n      if (!(Math.abs(particles[ax]) > 0 || Math.abs(particles[ay]) > 0)) {\n        let pYLength = maxHeight - particleY;\n        let pXLength = particleX;\n\n        // we calculate some random looking numbers and functions to have nice looking vaporizing front of particles\n        // todo consider to use noise;\n        pXLength += Math.tan((pXLength / 20.12) * time + seed) * 0.5;\n        pXLength += (particleX % deltaTSec) * 0.5;\n        pXLength += Math.sin((pXLength / 30 + 723.394) * time + seed * 12.5) * 11;\n        pYLength += Math.tan((pYLength / 0.45) * time + seed * 1.5) * 0.5;\n        pYLength += Math.cos((pYLength / 100 + 2323.234) * time + seed * 456.1) * 23;\n\n        const pLength = pXLength * pXLength + pYLength * pYLength;\n        if (pLength > accelerateRadiusPow) {\n          particles[ax] = Math.random();\n          particles[ay] = Math.random() * -1;\n        }\n      } else {\n        // use noise to flow along velocity field\n        const flowFieldAcc = WsThanosService.getXYFromFlowField(noise, seed, particleX, particleY);\n        const accelerationX = flowFieldAcc[0];\n        const accelerationY = flowFieldAcc[1];\n        particles[ax] += accelerationX;\n        particles[ay] += accelerationY;\n      }\n\n      // * Math.pow(1 + animationT, 4)\n      particles[dx] += particles[ax] * particleAcceleration * deltaTSec;\n      particles[dy] += particles[ay] * particleAcceleration * deltaTSec;\n      particles[x] += particles[dx] * deltaTSec;\n      particles[y] += particles[dy] * deltaTSec;\n      // fade particle out ( very late);\n      particles[a] *= 1 - Math.pow(animationT, 15); // 255 - Math.sqrt(particles[dx] * particles[dx] + particles[dy] * particles[dy]) / 1.2;\n    }\n  }\n\n  private static drawParticles(drawCtx: CanvasRenderingContext2D, particles: Float32Array): void {\n    const { width, height } = drawCtx.canvas;\n    drawCtx.clearRect(0, 0, width, height);\n    const image = drawCtx.getImageData(0, 0, width, height);\n    const imageData = image.data;\n    for (let i = 0; i < particles.length; i += PARTICLE_BYTE_LENGTH) {\n      const particleX = particles[i];\n      const particleY = particles[i + 1];\n      const pI = WsThanosService.getParticleIndicesForBase(i);\n      if (\n        particleX > width ||\n        particleX < 0 ||\n        particleY > height ||\n        particleY < 0 ||\n        particles[pI.a] < MIN_PARTICLE_ALPHA\n      ) {\n        continue;\n      }\n      const { r, g, b, a } = WsThanosService.getColorIndicesForCoord(~~particles[pI.x], ~~particles[pI.y], width);\n      imageData[r] = ~~particles[pI.r];\n      imageData[g] = ~~particles[pI.g];\n      imageData[b] = ~~particles[pI.b];\n      imageData[a] = ~~particles[pI.a];\n    }\n    drawCtx.putImageData(image, 0, 0);\n  }\n\n  private static prepareCanvasForVaporize(\n    divCanvas: HTMLCanvasElement,\n    maxParticleCount: number\n  ): {\n    particlesData: ParticlesData;\n    resultCanvas: HTMLCanvasElement;\n  } {\n    const { width, height } = divCanvas;\n\n    // scale result canvas to have more room to draw particles while vaporizing;\n    const resultHeight = height * HEIGHT_SCALE;\n    const resultWidth = width * WIDTH_SCALE;\n    const resultCanvas: HTMLCanvasElement = document.createElement('canvas');\n    resultCanvas.height = resultHeight;\n    resultCanvas.width = resultWidth;\n\n    const imageData = divCanvas.getContext('2d')?.getImageData(0, 0, width, height);\n    if (imageData == null) {\n      throw new Error('Could not get image data from canvas');\n    }\n    const particlesData = WsThanosService.createParticlesForImageData(imageData, maxParticleCount, resultHeight);\n    return { resultCanvas, particlesData };\n  }\n\n  private static createParticlesForImageData(\n    imageData: ImageData,\n    maxParticleCount: number,\n    resultHeight: number\n  ): { minParticleY: number; maxParticleX: number; particles: Float32Array } {\n    const { width, height } = imageData;\n    let particleCandidates = 0;\n    let particleCount = 0;\n\n    const particleCandiatesList: { x: number; y: number }[] = [];\n    for (let y = 0; y < height; y++) {\n      for (let x = 0; x < width; x++) {\n        const { a } = WsThanosService.getColorIndicesForCoord(x, y, width);\n        if (imageData.data[a] >= MIN_PARTICLE_ALPHA) {\n          particleCandidates++;\n          particleCandiatesList.push({ x, y });\n        }\n      }\n    }\n\n    const maxNumParticles = Math.min(particleCandidates, maxParticleCount);\n    const particles = new Float32Array(Float32Array.BYTES_PER_ELEMENT * maxNumParticles * PARTICLE_BYTE_LENGTH);\n\n    let maxParticleX = 0;\n    let minParticleY = resultHeight;\n    while (particleCount < maxNumParticles) {\n      // select random index from candiates\n      const index = ~~(Math.random() * particleCandiatesList.length);\n      const { x, y } = particleCandiatesList[index];\n\n      // overwrite index with last element to prevent double selection of particles\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      particleCandiatesList[index] = particleCandiatesList.pop()!;\n\n      maxParticleX = Math.max(maxParticleX, x);\n      minParticleY = Math.min(minParticleY, y);\n      const { dx, dy, ax, ay, r, g, b, a, ...xy } = WsThanosService.getParticleIndicesForBase(\n        particleCount * PARTICLE_BYTE_LENGTH\n      );\n      particles[xy.x] = x;\n      particles[xy.y] = y + resultHeight - height;\n      particles[dx] = 0;\n      particles[dy] = 0;\n      particles[ax] = 0;\n      particles[ay] = 0;\n\n      const indicesImage = WsThanosService.getColorIndicesForCoord(x, y, width);\n\n      particles[r] = imageData.data[indicesImage.r];\n      particles[g] = imageData.data[indicesImage.g];\n      particles[b] = imageData.data[indicesImage.b];\n      particles[a] = imageData.data[indicesImage.a];\n      particleCount++;\n    }\n    return { particles, maxParticleX, minParticleY };\n  }\n\n  private static getXYFromFlowField(noise: SimplexNoise, seed: number, x: number, y: number) {\n    const sampleX = noise.scaled3D(x, y, seed + 33.23, FLOW_FIELD_RES);\n    const sampleY = noise.scaled3D(x, seed / 13.23, y, FLOW_FIELD_RES) * -1;\n    return [sampleX, sampleY];\n  }\n\n  /**\n   * start the vaporize-effect.\n   *\n   * It's running outside the ngZone.\n   */\n  vaporize(elem: HTMLElement): Observable<AnimationState> {\n    return this.ngZone.runOutsideAngular(() => this.vaporizeIntern(elem));\n  }\n\n  private vaporizeIntern(elem: HTMLElement): Observable<AnimationState> {\n    elem.style.opacity = elem.style.opacity || '1';\n    elem.style.transition = `opacity ${Math.floor(this.thanosOptions.animationLength * 0.8)}ms ease-out`;\n    const noise = new SimplexNoise({ frequency: 0.01, min: 0 });\n    const seed = new Date().getDate() * Math.random();\n    const html2CanvasPromise: Promise<HTMLCanvasElement> = html2canvas(elem, {\n      backgroundColor: null,\n      scale: 1,\n      allowTaint: true,\n      windowHeight: window.innerHeight,\n      windowWidth: window.innerWidth,\n      scrollY: -window.scrollY,\n    });\n\n    return from(html2CanvasPromise).pipe(\n      map((canvasFromHtmlElem) => {\n        const canvasAndParticles = WsThanosService.prepareCanvasForVaporize(\n          canvasFromHtmlElem,\n          this.thanosOptions.maxParticleCount\n        );\n        const { resultCanvas } = canvasAndParticles;\n        if (elem.parentElement) {\n          elem.parentElement.style.position = elem.parentElement.style.position || 'relative';\n        }\n        resultCanvas.style.position = 'absolute';\n        resultCanvas.style.left = 0 + 'px';\n        resultCanvas.style.top = '-' + elem.getBoundingClientRect().height * (HEIGHT_SCALE - 1) + 'px';\n        resultCanvas.style.zIndex = '2000';\n        resultCanvas.style.pointerEvents = 'none';\n\n        elem.insertAdjacentElement('beforebegin', resultCanvas);\n        // this should start the transition above defined\n        elem.style.opacity = '0';\n        return canvasAndParticles;\n      }),\n      switchMap(({ resultCanvas, particlesData }) => {\n        let time = 0;\n        const { animationLength, maxParticleCount, particleAcceleration } = this.thanosOptions;\n        return interval(1000 / 60, animationFrameScheduler).pipe(\n          timeInterval(),\n          tap((deltaT) => (time += deltaT.interval)),\n          map(\n            (deltaT) =>\n              ({\n                deltaTSec: deltaT.interval / 1000,\n                animationT: time / animationLength,\n                maxWidth: resultCanvas.width,\n                maxHeight: resultCanvas.height,\n              } as AnimationState)\n          ),\n          tap((animationState) => {\n            WsThanosService.updateParticles({\n              particlesData,\n              animationState,\n              thanosOptions: {\n                animationLength,\n                maxParticleCount,\n                particleAcceleration,\n              },\n              noise,\n              seed,\n            });\n            const context = resultCanvas.getContext('2d');\n            if (context) {\n              WsThanosService.drawParticles(context, particlesData.particles);\n            }\n          }),\n          takeWhile((animationState) => animationState.animationT <= 1),\n          tap({\n            complete: () => {\n              return resultCanvas.remove();\n            },\n          })\n        );\n      })\n    );\n  }\n}\n"]}

package/{esm2020 → esm2022}/wolsok-thanos.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './index';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29sc29rLXRoYW5vcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvcHVibGljL3dzLXRoYW5vcy9zcmMvd29sc29rLXRoYW5vcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/index.d.ts

@@ -1,6 +1,6 @@
-export * from './lib/ws-thanos.service';
-export * from './lib/ws-thanos.directive';
-export * from './lib/ws-thanos-options.token';
-export * from './lib/ws-thanos.options';
-export * from './lib/create-ws-thanos-options';
-export * from './lib/simplex-noise';
+export * from './lib/ws-thanos.service';
+export * from './lib/ws-thanos.directive';
+export * from './lib/ws-thanos-options.token';
+export * from './lib/ws-thanos.options';
+export * from './lib/create-ws-thanos-options';
+export * from './lib/simplex-noise';

package/lib/create-ws-thanos-options.d.ts

@@ -1,2 +1,2 @@
-import { WsThanosOptions } from './ws-thanos.options';
-export declare function createWsThanosOptions(options?: Partial<WsThanosOptions>): WsThanosOptions;
+import { WsThanosOptions } from './ws-thanos.options';
+export declare function createWsThanosOptions(options?: Partial<WsThanosOptions>): WsThanosOptions;

package/lib/simplex-noise-options.d.ts

@@ -1,9 +1,9 @@
-export interface SimplexNoiseOptions {
-    amplitude: number;
-    frequency: number;
-    max: number;
-    min: number;
-    octaves: number;
-    persistence: number;
-    random: () => number;
-}
+export interface SimplexNoiseOptions {
+    amplitude: number;
+    frequency: number;
+    max: number;
+    min: number;
+    octaves: number;
+    persistence: number;
+    random: () => number;
+}

package/lib/simplex-noise.d.ts

@@ -1,18 +1,18 @@
-import type { SimplexNoiseOptions } from './simplex-noise-options';
-export declare class SimplexNoise {
-    constructor(options?: Partial<SimplexNoiseOptions>);
-    static G3: number;
-    static GRAD3D: number[][];
-    readonly amplitude: number;
-    readonly frequency: number;
-    readonly octaves: number;
-    readonly perm: Uint8Array;
-    readonly permMod12: Uint8Array;
-    readonly persistence: number;
-    readonly random: () => number;
-    readonly scale: (value: number) => number;
-    private memScale3D;
-    dot(gs: number[], coords: number[]): number;
-    raw3D(x: number, y: number, z: number): number;
-    scaled3D(x: number, y: number, z: number, resolution: number): number;
-}
+import type { SimplexNoiseOptions } from './simplex-noise-options';
+export declare class SimplexNoise {
+    constructor(options?: Partial<SimplexNoiseOptions>);
+    static G3: number;
+    static GRAD3D: number[][];
+    readonly amplitude: number;
+    readonly frequency: number;
+    readonly octaves: number;
+    readonly perm: Uint8Array;
+    readonly permMod12: Uint8Array;
+    readonly persistence: number;
+    readonly random: () => number;
+    readonly scale: (value: number) => number;
+    private memScale3D;
+    dot(gs: number[], coords: number[]): number;
+    raw3D(x: number, y: number, z: number): number;
+    scaled3D(x: number, y: number, z: number, resolution: number): number;
+}

package/lib/ws-thanos-options.token.d.ts

@@ -1,4 +1,4 @@
-import { InjectionToken, Provider } from '@angular/core';
-import type { WsThanosOptions } from './ws-thanos.options';
-export declare const WS_THANOS_OPTIONS_TOKEN: InjectionToken<WsThanosOptions>;
-export declare function provideWsThanosOptions(options?: Partial<WsThanosOptions>): Provider;
+import { InjectionToken, Provider } from '@angular/core';
+import type { WsThanosOptions } from './ws-thanos.options';
+export declare const WS_THANOS_OPTIONS_TOKEN: InjectionToken<WsThanosOptions>;
+export declare function provideWsThanosOptions(options?: Partial<WsThanosOptions>): Provider;

package/lib/ws-thanos.directive.d.ts

@@ -1,18 +1,18 @@
-import { ElementRef, NgZone, OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import type { WsThanosOptions } from './ws-thanos.options';
-import { WsThanosService } from './ws-thanos.service';
-import * as i0 from "@angular/core";
-export declare class WsThanosDirective implements OnDestroy {
-    private readonly vaporizeDomElem;
-    private readonly thanosService;
-    private readonly thanosOptions;
-    private readonly ngZone;
-    private subscription?;
-    private wsThanosComplete;
-    constructor(vaporizeDomElem: ElementRef<HTMLElement>, thanosService: WsThanosService, thanosOptions: WsThanosOptions, ngZone: NgZone);
-    vaporize(removeElem?: boolean): Observable<void>;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WsThanosDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<WsThanosDirective, "[wsThanos], ws-thanos", ["thanos"], {}, { "wsThanosComplete": "wsThanosComplete"; }, never, never, true>;
-}
+import { ElementRef, NgZone, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import type { WsThanosOptions } from './ws-thanos.options';
+import { WsThanosService } from './ws-thanos.service';
+import * as i0 from "@angular/core";
+export declare class WsThanosDirective implements OnDestroy {
+    private readonly vaporizeDomElem;
+    private readonly thanosService;
+    private readonly thanosOptions;
+    private readonly ngZone;
+    private subscription?;
+    private wsThanosComplete;
+    constructor(vaporizeDomElem: ElementRef<HTMLElement>, thanosService: WsThanosService, thanosOptions: WsThanosOptions, ngZone: NgZone);
+    vaporize(removeElem?: boolean): Observable<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsThanosDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WsThanosDirective, "[wsThanos], ws-thanos", ["thanos"], {}, { "wsThanosComplete": "wsThanosComplete"; }, never, never, true, never>;
+}

package/lib/ws-thanos.options.d.ts

@@ -1,5 +1,5 @@
-export interface WsThanosOptions {
-    animationLength: number;
-    maxParticleCount: number;
-    particleAcceleration: number;
-}
+export interface WsThanosOptions {
+    animationLength: number;
+    maxParticleCount: number;
+    particleAcceleration: number;
+}

package/lib/ws-thanos.service.d.ts

@@ -1,32 +1,32 @@
-import { NgZone } from '@angular/core';
-import { Observable } from 'rxjs';
-import type { WsThanosOptions } from './ws-thanos.options';
-import * as i0 from "@angular/core";
-interface AnimationState {
-    deltaTSec: number;
-    animationT: number;
-    maxWidth: number;
-    maxHeight: number;
-}
-export declare class WsThanosService {
-    private thanosOptions;
-    private ngZone;
-    constructor(thanosOptions: WsThanosOptions, ngZone: NgZone);
-    private static getParticleIndicesForBase;
-    private static getColorIndicesForCoord;
-    private static updateParticles;
-    private static drawParticles;
-    private static prepareCanvasForVaporize;
-    private static createParticlesForImageData;
-    private static getXYFromFlowField;
-    /**
-     * start the vaporize-effect.
-     *
-     * It's running outside the ngZone.
-     */
-    vaporize(elem: HTMLElement): Observable<AnimationState>;
-    private vaporizeIntern;
-    static ɵfac: i0.ɵɵFactoryDeclaration<WsThanosService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<WsThanosService>;
-}
-export {};
+import { NgZone } from '@angular/core';
+import { Observable } from 'rxjs';
+import type { WsThanosOptions } from './ws-thanos.options';
+import * as i0 from "@angular/core";
+interface AnimationState {
+    deltaTSec: number;
+    animationT: number;
+    maxWidth: number;
+    maxHeight: number;
+}
+export declare class WsThanosService {
+    private thanosOptions;
+    private ngZone;
+    constructor(thanosOptions: WsThanosOptions, ngZone: NgZone);
+    private static getParticleIndicesForBase;
+    private static getColorIndicesForCoord;
+    private static updateParticles;
+    private static drawParticles;
+    private static prepareCanvasForVaporize;
+    private static createParticlesForImageData;
+    private static getXYFromFlowField;
+    /**
+     * start the vaporize-effect.
+     *
+     * It's running outside the ngZone.
+     */
+    vaporize(elem: HTMLElement): Observable<AnimationState>;
+    private vaporizeIntern;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsThanosService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WsThanosService>;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wolsok/thanos",
-  "version": "3.0.1",
-  "description": "wolsok's implementation of a cool thanos vaporizing effect for destroying dom elements",
+  "version": "16.0.0",
+  "description": "Wolf Soko's implementation of a cool Thanos snapping vaporizing effect for destroying dom elements",
   "bugs": {
     "url": "https://github.com/WolfSoko/wol-sok-mono/issues"
   },
@@ -9,6 +9,7 @@
   "repository": "https://github.com/WolfSoko/wol-sok-mono/tree/main/libs/public/ws-thanos",
   "license": "MIT",
   "keywords": [
+    "wolf soko",
     "wolsok",
     "angular",
     "angular-lib",
@@ -19,33 +20,31 @@
     "vaporize",
     "vaporizing",
     "Avengers",
-    "Marvel"
+    "Marvel",
+    "npm"
   ],
   "peerDependencies": {
-    "@angular/common": "^14.2.9",
-    "@angular/core": "^14.2.9",
+    "@angular/common": "^16.0.0",
+    "@angular/core": "^16.0.0",
     "html2canvas": "^1.4.1",
-    "@angular/platform-browser": "14.2.9",
-    "rxjs": "7.5.7",
-    "zone.js": "0.11.8",
-    "@angular/platform-browser-dynamic": "14.2.9"
+    "@angular/platform-browser": "16.0.0",
+    "rxjs": "7.8.1",
+    "zone.js": "0.13.0",
+    "@angular/platform-browser-dynamic": "16.0.0"
   },
   "dependencies": {
-    "tslib": "2.4.1"
+    "tslib": "2.5.0"
   },
-  "module": "esm2020/wolsok-thanos.mjs",
-  "es2020": "esm2020/wolsok-thanos.mjs",
-  "esm2020": "esm2020/wolsok-thanos.mjs",
+  "module": "esm2022/wolsok-thanos.mjs",
   "typings": "index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
-      "es2020": "./esm2020/wolsok-thanos.mjs",
-      "esm2020": "./esm2020/wolsok-thanos.mjs",
-      "default": "./esm2020/wolsok-thanos.mjs"
+      "esm2022": "./esm2022/wolsok-thanos.mjs",
+      "esm": "./esm2022/wolsok-thanos.mjs",
+      "default": "./esm2022/wolsok-thanos.mjs"
     }
   },
   "sideEffects": false

package/esm2020/lib/create-ws-thanos-options.mjs

@@ -1,9 +0,0 @@
-export function createWsThanosOptions(options) {
-    return {
-        animationLength: 5000,
-        maxParticleCount: 400000,
-        particleAcceleration: 30,
-        ...options,
-    };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXdzLXRoYW5vcy1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wdWJsaWMvd3MtdGhhbm9zL3NyYy9saWIvY3JlYXRlLXdzLXRoYW5vcy1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxxQkFBcUIsQ0FDbkMsT0FBa0M7SUFFbEMsT0FBTztRQUNMLGVBQWUsRUFBRSxJQUFJO1FBQ3JCLGdCQUFnQixFQUFFLE1BQU07UUFDeEIsb0JBQW9CLEVBQUUsRUFBRTtRQUN4QixHQUFHLE9BQU87S0FDWCxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdzVGhhbm9zT3B0aW9ucyB9IGZyb20gJy4vd3MtdGhhbm9zLm9wdGlvbnMnO1xuXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlV3NUaGFub3NPcHRpb25zKFxuICBvcHRpb25zPzogUGFydGlhbDxXc1RoYW5vc09wdGlvbnM+XG4pOiBXc1RoYW5vc09wdGlvbnMge1xuICByZXR1cm4ge1xuICAgIGFuaW1hdGlvbkxlbmd0aDogNTAwMCxcbiAgICBtYXhQYXJ0aWNsZUNvdW50OiA0MDAwMDAsXG4gICAgcGFydGljbGVBY2NlbGVyYXRpb246IDMwLFxuICAgIC4uLm9wdGlvbnMsXG4gIH07XG59XG4iXX0=