@wolsok/thanos 3.0.1 → 16.0.0

package/README.md

@@ -1,107 +1,109 @@
-# @wolsok/thanos
-
-An angular directive that vaporizes your DOM Elements like Thanos. This library is generated with [Nx](https://nx.dev).
-
-#### Live Demo:
-Click the technology cards on https://angularexamples.wolsok.de
-
-## Usage
-
-#### Dependencies:
-
-To install run
-
-```
-npm install @wolsok/thanos --save
-```
-#### Prepare your angular app:
-
-Add `WsThanosDirective` to your module/standalone component.
-
-```typescript
-@NgModule_or_@Component({
-  ...,
-  imports: [
-    ...
-    WsThanosDirective
-  ],
-  providers: [
-    // override the default options
-    provideWsThanosOptions({
-      animationLength: 2000,
-      particleAcceleration: 50,
-      maxParticleCount: 10000
-    }),
-  ]
-})
-```
-
-You can also add WsThanosDirective to your shared module exports.
-
-```typescript
-@NgModule({
-  imports: [WsThanosDirective],
-  exports: [
-    WsThanosDirective
-  ]
-})
-export class SharedModule {
-}
-```
-
-#### `WsThanosOptions` to configure ws-thanos:
-| field                |  type  | default |                        description |
-| -------------------- | :----: | ------: | ---------------------------------: |
-| animationLength      | number |    5000 |         the animation length in ms |
-| maxParticleCount     | number |  400000 |            max amount of particles |
-| particleAcceleration | number |      30 | speed of the particle acceleration |
-
-### `WsThanosDirective` usage
-
-Use the directive `wsThanos` on your element and reference it using `@ViewChild(WsThanosDirective)` in your component or
-directly in html via template ref:
-
-```
-<div wsThanos
-  #thanos="thanos"
-  (wsThanosComplete)=onComplete()>
-  This div will be vaporized on click
-  </div>
-<button (click)="thanos.vaporize(removeElement)">
-```
-
-### `WsThanosService` usage
-
-Inject the 'WsThanosService' into your class. Call 'vaporize()' and subscribe to it.
-
-## Collaboration
-
-Send issues or PRs to https://github.com/wolsok/wol-sok-mono
-
-Run `nx test ws-thanos` to execute unit tests.
-
-## Migration
-From `1.0.1` to `2.0.0`
-* Replace `WsThanosModule` in imports and exports with `WsThanosDirective`
-* Replace `WsThanosModule.forRoot(options)`:
-  Before: 
-  ```typescript
-  @NgModule({
-   imports: [WsThanosModule.forRoot(options)]
-  })
-  ```
-  After:
-  ```typescript
-  @NgModule({
-   imports: [WsThanosDirective],
-   providers: [
-     provideWsThanosOptions(options)
-   ]
-  })
-  ```
-
-From: `sc-thanos` to `@wolsok/thanos` 
-* Remove old version `npm uninstall sc-thanos`
-* Install `npm install @wolsok/thanos --save`
-* The earlier name of this component was `scThanos`. Just switch to `wsThanos`
-
+# @wolsok/thanos
+
+An angular directive that vaporizes your DOM Elements like Thanos snaps his fingers. This library is generated with [Nx](https://nx.dev).
+
+#### Live Demo:
+
+Click the technology cards on https://angularexamples.wolsok.de/home?thanosDemo=true
+
+## Usage
+
+#### Dependencies:
+
+To install run
+
+```
+npm install @wolsok/thanos --save
+```
+
+#### Prepare your angular app:
+
+Add `WsThanosDirective` to your module/standalone component.
+
+```typescript
+@NgModule_or_@Component({
+  ...,
+  imports: [
+    ...
+    WsThanosDirective
+  ],
+  providers: [
+    // override the default options
+    provideWsThanosOptions({
+      animationLength: 2000,
+      particleAcceleration: 50,
+      maxParticleCount: 10000
+    }),
+  ]
+})
+```
+
+You can also add WsThanosDirective to your shared module exports.
+
+```typescript
+@NgModule({
+  imports: [WsThanosDirective],
+  exports: [WsThanosDirective],
+})
+export class SharedModule {}
+```
+
+#### `WsThanosOptions` to configure ws-thanos:
+
+| field                |  type  | default |                        description |
+| -------------------- | :----: | ------: | ---------------------------------: |
+| animationLength      | number |    5000 |         the animation length in ms |
+| maxParticleCount     | number |  400000 |            max amount of particles |
+| particleAcceleration | number |      30 | speed of the particle acceleration |
+
+### `WsThanosDirective` usage
+
+Use the directive `wsThanos` on your element and reference it using `@ViewChild(WsThanosDirective)` in your component or
+directly in html via template ref:
+
+```
+<div wsThanos
+  #thanos="thanos"
+  (wsThanosComplete)=onComplete()>
+  This div will be vaporized on click
+  </div>
+<button (click)="thanos.vaporize(removeElement)">
+```
+
+### `WsThanosService` usage
+
+Inject the 'WsThanosService' into your class. Call 'vaporize()' and subscribe to it.
+
+## Collaboration
+
+Send issues or PRs to https://github.com/wolsok/wol-sok-mono
+
+Run `nx test ws-thanos` to execute unit tests.
+
+## Migration
+
+From `1.0.1` to `2.0.0`
+
+- Replace `WsThanosModule` in imports and exports with `WsThanosDirective`
+- Replace `WsThanosModule.forRoot(options)`:
+  Before:
+  ```typescript
+  @NgModule({
+   imports: [WsThanosModule.forRoot(options)]
+  })
+  ```
+  After:
+  ```typescript
+  @NgModule({
+   imports: [WsThanosDirective],
+   providers: [
+     provideWsThanosOptions(options)
+   ]
+  })
+  ```
+
+From: `sc-thanos` to `@wolsok/thanos`
+
+- Remove old version `npm uninstall sc-thanos`
+- Install `npm install @wolsok/thanos --save`
+- The earlier name of this component was `scThanos`. Just switch to `wsThanos`

package/{esm2020 → esm2022}/index.mjs

@@ -1,10 +1,10 @@
-/*
- * Public API Surface of ws-thanos
- */
-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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3B1YmxpYy93cy10aGFub3Mvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygd3MtdGhhbm9zXHJcbiAqL1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi93cy10aGFub3Muc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzLXRoYW5vcy5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi93cy10aGFub3Mtb3B0aW9ucy50b2tlbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzLXRoYW5vcy5vcHRpb25zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvY3JlYXRlLXdzLXRoYW5vcy1vcHRpb25zJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2ltcGxleC1ub2lzZSc7XHJcbiJdfQ==
+/*
+ * Public API Surface of ws-thanos
+ */
+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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3B1YmxpYy93cy10aGFub3Mvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHdzLXRoYW5vc1xuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi93cy10aGFub3Muc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi93cy10aGFub3MuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzLXRoYW5vcy1vcHRpb25zLnRva2VuJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3dzLXRoYW5vcy5vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NyZWF0ZS13cy10aGFub3Mtb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaW1wbGV4LW5vaXNlJztcbiJdfQ==

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

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

package/{esm2020 → esm2022}/lib/simplex-noise-options.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxleC1ub2lzZS1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9wdWJsaWMvd3MtdGhhbm9zL3NyYy9saWIvc2ltcGxleC1ub2lzZS1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNpbXBsZXhOb2lzZU9wdGlvbnMge1xuICBhbXBsaXR1ZGU6IG51bWJlcjsgLy8gVGhlIGJhc2UgYW1wbGl0dWRlIChkZWZhdWx0OiAxLjApXG4gIGZyZXF1ZW5jeTogbnVtYmVyOyAvLyBUaGUgYmFzZSBmcmVxdWVuY3kgKGRlZmF1bHQ6IDEuMClcbiAgbWF4OiBudW1iZXI7IC8vIFRoZSBtYXhpbXVtIHNjYWxlZCB2YWx1ZSB0byByZXR1cm4gKGVmZmVjdGl2ZSBkZWZhdWx0OiAxLjApXG4gIG1pbjogbnVtYmVyOyAvLyBUaGUgbWluaW11bSBzY2FsZWQgdmFsdWUgdG8gcmV0dXJuIChlZmZlY3RpdmUgZGVmYXVsdDogLTEuMClcbiAgb2N0YXZlczogbnVtYmVyOyAvLyBJbnRlZ2VyOyB0aGUgbnVtYmVyIG9mIG9jdGF2ZXMgdG8gc3VtIGZvciBub2lzZSBnZW5lcmF0aW9uIChkZWZhdWx0OiAxKVxuICBwZXJzaXN0ZW5jZTogbnVtYmVyOyAvLyBUaGUgcGVyc2lzdGVuY2Ugb2YgYW1wbGl0dWRlIHBlciBvY3RhdmUgKGRlZmF1bHQ6IDAuNSlcbiAgcmFuZG9tOiAoKSA9PiBudW1iZXI7IC8vIEEgZnVuY3Rpb24gdGhhdCBnZW5lcmF0ZXMgcmFuZG9tIHZhbHVlcyBiZXR3ZWVuIDAgYW5kIDEgKGRlZmF1bHQ6IE1hdGgucmFuZG9tKVxufVxuIl19

package/esm2022/lib/simplex-noise.mjs

@@ -0,0 +1,194 @@
+class SimplexNoise {
+    constructor(options) {
+        const { min, max, random, amplitude, frequency, octaves, persistence } = createOptionsWithDefaults(options);
+        this.random = random;
+        this.amplitude = amplitude;
+        this.frequency = frequency;
+        this.octaves = octaves;
+        this.persistence = persistence;
+        this.scale = min === -1 && max === 1 ? (value) => value : (value) => min + ((value + 1) / 2) * (max - min);
+        const p = new Uint8Array(256);
+        for (let i = 0; i < 256; i++) {
+            p[i] = i;
+        }
+        let n;
+        let q;
+        for (let i = 255; i > 0; i--) {
+            n = Math.floor((i + 1) * this.random());
+            q = p[i];
+            p[i] = p[n];
+            p[n] = q;
+        }
+        this.perm = new Uint8Array(512);
+        this.permMod12 = new Uint8Array(512);
+        for (let i = 0; i < 512; i++) {
+            this.perm[i] = p[i & 255];
+            this.permMod12[i] = this.perm[i] % 12;
+        }
+    }
+    static G3 = 1.0 / 6.0;
+    static GRAD3D = [
+        [1, 1, 0],
+        [-1, 1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+        [1, 0, 1],
+        [-1, 0, 1],
+        [1, 0, -1],
+        [-1, 0, -1],
+        [0, 1, 1],
+        [0, -1, -1],
+        [0, 1, -1],
+        [0, -1, -1],
+    ];
+    amplitude;
+    frequency;
+    octaves;
+    perm;
+    permMod12;
+    persistence;
+    random;
+    scale;
+    memScale3D = {};
+    dot(gs, coords) {
+        return gs.slice(0, Math.min(gs.length, coords.length)).reduce((total, g, i) => total + g * coords[i], 0);
+    }
+    raw3D(x, y, z) {
+        // Skew the input space to determine which simplex cell we're in
+        const s = (x + y + z) / 3.0; // Very nice and simple skew factor for 3D
+        const i = Math.floor(x + s);
+        const j = Math.floor(y + s);
+        const k = Math.floor(z + s);
+        const t = (i + j + k) * SimplexNoise.G3;
+        const X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+        const Y0 = j - t;
+        const Z0 = k - t;
+        const x0 = x - X0; // The x,y,z distances from the cell origin
+        const y0 = y - Y0;
+        const z0 = z - Z0;
+        // Determine which simplex we are in
+        let i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
+        let i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
+        if (x0 >= y0) {
+            if (y0 >= z0) {
+                i1 = i2 = j2 = 1;
+                j1 = k1 = k2 = 0;
+            }
+            else if (x0 >= z0) {
+                i1 = i2 = k2 = 1;
+                j1 = k1 = j2 = 0;
+            }
+            else {
+                k1 = i2 = k2 = 1;
+                i1 = j1 = j2 = 0;
+            }
+        }
+        else {
+            if (y0 < z0) {
+                k1 = j2 = k2 = 1;
+                i1 = j1 = i2 = 0;
+            }
+            else if (x0 < z0) {
+                j1 = j2 = k2 = 1;
+                i1 = k1 = i2 = 0;
+            }
+            else {
+                j1 = i2 = j2 = 1;
+                i1 = k1 = k2 = 0;
+            }
+        }
+        const x1 = x0 - i1 + SimplexNoise.G3; // Offsets for second corner in (x,y,z) coords
+        const y1 = y0 - j1 + SimplexNoise.G3;
+        const z1 = z0 - k1 + SimplexNoise.G3;
+        const x2 = x0 - i2 + 2.0 * SimplexNoise.G3; // Offsets for third corner in (x,y,z) coords
+        const y2 = y0 - j2 + 2.0 * SimplexNoise.G3;
+        const z2 = z0 - k2 + 2.0 * SimplexNoise.G3;
+        const x3 = x0 - 1.0 + 3.0 * SimplexNoise.G3; // Offsets for last corner in (x,y,z) coords
+        const y3 = y0 - 1.0 + 3.0 * SimplexNoise.G3;
+        const z3 = z0 - 1.0 + 3.0 * SimplexNoise.G3;
+        // Work out the hashed gradient indices of the four simplex corners
+        const ii = i & 255;
+        const jj = j & 255;
+        const kk = k & 255;
+        const gi0 = this.permMod12[ii + this.perm[jj + this.perm[kk]]];
+        const gi1 = this.permMod12[ii + i1 + this.perm[jj + j1 + this.perm[kk + k1]]];
+        const gi2 = this.permMod12[ii + i2 + this.perm[jj + j2 + this.perm[kk + k2]]];
+        const gi3 = this.permMod12[ii + 1 + this.perm[jj + 1 + this.perm[kk + 1]]];
+        // Calculate the contribution from the four corners
+        const t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
+        const n0 = t0 < 0 ? 0.0 : Math.pow(t0, 4) * this.dot(SimplexNoise.GRAD3D[gi0], [x0, y0, z0]);
+        const t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
+        const n1 = t1 < 0 ? 0.0 : Math.pow(t1, 4) * this.dot(SimplexNoise.GRAD3D[gi1], [x1, y1, z1]);
+        const t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
+        const n2 = t2 < 0 ? 0.0 : Math.pow(t2, 4) * this.dot(SimplexNoise.GRAD3D[gi2], [x2, y2, z2]);
+        const t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
+        const n3 = t3 < 0 ? 0.0 : Math.pow(t3, 4) * this.dot(SimplexNoise.GRAD3D[gi3], [x3, y3, z3]);
+        // Add contributions from each corner to get the final noise value.
+        // The result is scaled to stay just inside [-1,1]
+        return 94.68493150681972 * (n0 + n1 + n2 + n3);
+    }
+    scaled3D(x, y, z, resolution) {
+        const memIndex = `${Math.round(x * resolution)}${Math.round(y * resolution)}${Math.round(z * resolution)}`;
+        const memElem = this.memScale3D[memIndex];
+        if (memElem != null) {
+            return memElem;
+        }
+        let amplitude = this.amplitude;
+        let frequency = this.frequency;
+        let maxAmplitude = 0;
+        let noise = 0;
+        for (let i = 0; i < this.octaves; i++) {
+            noise += this.raw3D(x * frequency, y * frequency, z * frequency) * amplitude;
+            maxAmplitude += amplitude;
+            amplitude *= this.persistence;
+            frequency *= 2;
+        }
+        const result = this.scale(noise / maxAmplitude);
+        this.memScale3D[memIndex] = result;
+        return result;
+    }
+}
+export { SimplexNoise };
+function createOptionsWithDefaults(options) {
+    if (options != null) {
+        if (options['amplitude'] && typeof options.amplitude !== 'number') {
+            throw new Error('options.amplitude must be a number');
+        }
+        if (options['frequency'] && typeof options.frequency !== 'number') {
+            throw new Error('options.frequency must be a number');
+        }
+        if (options['octaves'] &&
+            (typeof options.octaves !== 'number' ||
+                !isFinite(options.octaves) ||
+                Math.floor(options.octaves) !== options.octaves)) {
+            throw new Error('options.octaves must be an integer');
+        }
+        if (options['persistence'] && typeof options.persistence !== 'number') {
+            throw new Error('options.persistence must be a number');
+        }
+        if (options['random'] && typeof options.random !== 'function') {
+            throw new Error('options.random must be a function');
+        }
+        if (options['min'] && typeof options.min !== 'number') {
+            throw new Error('options.min must be a number');
+        }
+        if (options['max'] && typeof options.max !== 'number') {
+            throw new Error('options.max must be a number');
+        }
+    }
+    const optionsResult = {
+        amplitude: 1.0,
+        frequency: 1.0,
+        max: 1.0,
+        min: -1.0,
+        octaves: 1,
+        persistence: 0.5,
+        random: Math.random,
+        ...options,
+    };
+    if (optionsResult.min > optionsResult.max) {
+        throw new Error('min must be smaller max');
+    }
+    return optionsResult;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simplex-noise.js","sourceRoot":"","sources":["../../../../../../libs/public/ws-thanos/src/lib/simplex-noise.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SimplexNoiseOptions } from './simplex-noise-options';\n\nexport class SimplexNoise {\n  constructor(options?: Partial<SimplexNoiseOptions>) {\n    const { min, max, random, amplitude, frequency, octaves, persistence } = createOptionsWithDefaults(options);\n\n    this.random = random;\n    this.amplitude = amplitude;\n    this.frequency = frequency;\n    this.octaves = octaves;\n    this.persistence = persistence;\n\n    this.scale = min === -1 && max === 1 ? (value) => value : (value) => min + ((value + 1) / 2) * (max - min);\n\n    const p = new Uint8Array(256);\n    for (let i = 0; i < 256; i++) {\n      p[i] = i;\n    }\n\n    let n: number;\n    let q: number;\n    for (let i = 255; i > 0; i--) {\n      n = Math.floor((i + 1) * this.random());\n      q = p[i];\n      p[i] = p[n];\n      p[n] = q;\n    }\n\n    this.perm = new Uint8Array(512);\n    this.permMod12 = new Uint8Array(512);\n    for (let i = 0; i < 512; i++) {\n      this.perm[i] = p[i & 255];\n      this.permMod12[i] = this.perm[i] % 12;\n    }\n  }\n\n  static G3 = 1.0 / 6.0;\n\n  static GRAD3D = [\n    [1, 1, 0],\n    [-1, 1, 0],\n    [1, -1, 0],\n    [-1, -1, 0],\n    [1, 0, 1],\n    [-1, 0, 1],\n    [1, 0, -1],\n    [-1, 0, -1],\n    [0, 1, 1],\n    [0, -1, -1],\n    [0, 1, -1],\n    [0, -1, -1],\n  ];\n\n  readonly amplitude: number;\n  readonly frequency: number;\n  readonly octaves: number;\n  readonly perm: Uint8Array;\n  readonly permMod12: Uint8Array;\n  readonly persistence: number;\n  readonly random: () => number;\n  readonly scale: (value: number) => number;\n  private memScale3D: { [key: string]: number } = {};\n\n  dot(gs: number[], coords: number[]): number {\n    return gs.slice(0, Math.min(gs.length, coords.length)).reduce((total, g, i) => total + g * coords[i], 0);\n  }\n\n  raw3D(x: number, y: number, z: number): number {\n    // Skew the input space to determine which simplex cell we're in\n    const s = (x + y + z) / 3.0; // Very nice and simple skew factor for 3D\n    const i = Math.floor(x + s);\n    const j = Math.floor(y + s);\n    const k = Math.floor(z + s);\n    const t = (i + j + k) * SimplexNoise.G3;\n    const X0 = i - t; // Unskew the cell origin back to (x,y,z) space\n    const Y0 = j - t;\n    const Z0 = k - t;\n    const x0 = x - X0; // The x,y,z distances from the cell origin\n    const y0 = y - Y0;\n    const z0 = z - Z0;\n\n    // Determine which simplex we are in\n    let i1: number, j1: number, k1: number; // Offsets for second corner of simplex in (i,j,k) coords\n    let i2: number, j2: number, k2: number; // Offsets for third corner of simplex in (i,j,k) coords\n    if (x0 >= y0) {\n      if (y0 >= z0) {\n        i1 = i2 = j2 = 1;\n        j1 = k1 = k2 = 0;\n      } else if (x0 >= z0) {\n        i1 = i2 = k2 = 1;\n        j1 = k1 = j2 = 0;\n      } else {\n        k1 = i2 = k2 = 1;\n        i1 = j1 = j2 = 0;\n      }\n    } else {\n      if (y0 < z0) {\n        k1 = j2 = k2 = 1;\n        i1 = j1 = i2 = 0;\n      } else if (x0 < z0) {\n        j1 = j2 = k2 = 1;\n        i1 = k1 = i2 = 0;\n      } else {\n        j1 = i2 = j2 = 1;\n        i1 = k1 = k2 = 0;\n      }\n    }\n\n    const x1 = x0 - i1 + SimplexNoise.G3; // Offsets for second corner in (x,y,z) coords\n    const y1 = y0 - j1 + SimplexNoise.G3;\n    const z1 = z0 - k1 + SimplexNoise.G3;\n    const x2 = x0 - i2 + 2.0 * SimplexNoise.G3; // Offsets for third corner in (x,y,z) coords\n    const y2 = y0 - j2 + 2.0 * SimplexNoise.G3;\n    const z2 = z0 - k2 + 2.0 * SimplexNoise.G3;\n    const x3 = x0 - 1.0 + 3.0 * SimplexNoise.G3; // Offsets for last corner in (x,y,z) coords\n    const y3 = y0 - 1.0 + 3.0 * SimplexNoise.G3;\n    const z3 = z0 - 1.0 + 3.0 * SimplexNoise.G3;\n\n    // Work out the hashed gradient indices of the four simplex corners\n    const ii = i & 255;\n    const jj = j & 255;\n    const kk = k & 255;\n    const gi0 = this.permMod12[ii + this.perm[jj + this.perm[kk]]];\n    const gi1 = this.permMod12[ii + i1 + this.perm[jj + j1 + this.perm[kk + k1]]];\n    const gi2 = this.permMod12[ii + i2 + this.perm[jj + j2 + this.perm[kk + k2]]];\n    const gi3 = this.permMod12[ii + 1 + this.perm[jj + 1 + this.perm[kk + 1]]];\n\n    // Calculate the contribution from the four corners\n    const t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;\n    const n0 = t0 < 0 ? 0.0 : Math.pow(t0, 4) * this.dot(SimplexNoise.GRAD3D[gi0], [x0, y0, z0]);\n    const t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;\n    const n1 = t1 < 0 ? 0.0 : Math.pow(t1, 4) * this.dot(SimplexNoise.GRAD3D[gi1], [x1, y1, z1]);\n    const t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;\n    const n2 = t2 < 0 ? 0.0 : Math.pow(t2, 4) * this.dot(SimplexNoise.GRAD3D[gi2], [x2, y2, z2]);\n    const t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;\n    const n3 = t3 < 0 ? 0.0 : Math.pow(t3, 4) * this.dot(SimplexNoise.GRAD3D[gi3], [x3, y3, z3]);\n\n    // Add contributions from each corner to get the final noise value.\n    // The result is scaled to stay just inside [-1,1]\n    return 94.68493150681972 * (n0 + n1 + n2 + n3);\n  }\n\n  scaled3D(x: number, y: number, z: number, resolution: number): number {\n    const memIndex = `${Math.round(x * resolution)}${Math.round(y * resolution)}${Math.round(z * resolution)}`;\n    const memElem = this.memScale3D[memIndex];\n    if (memElem != null) {\n      return memElem;\n    }\n\n    let amplitude = this.amplitude;\n    let frequency = this.frequency;\n    let maxAmplitude = 0;\n    let noise = 0;\n\n    for (let i = 0; i < this.octaves; i++) {\n      noise += this.raw3D(x * frequency, y * frequency, z * frequency) * amplitude;\n      maxAmplitude += amplitude;\n      amplitude *= this.persistence;\n      frequency *= 2;\n    }\n    const result = this.scale(noise / maxAmplitude);\n    this.memScale3D[memIndex] = result;\n    return result;\n  }\n}\n\nfunction createOptionsWithDefaults(options?: Partial<SimplexNoiseOptions>) {\n  if (options != null) {\n    if (options['amplitude'] && typeof options.amplitude !== 'number') {\n      throw new Error('options.amplitude must be a number');\n    }\n\n    if (options['frequency'] && typeof options.frequency !== 'number') {\n      throw new Error('options.frequency must be a number');\n    }\n\n    if (\n      options['octaves'] &&\n      (typeof options.octaves !== 'number' ||\n        !isFinite(options.octaves) ||\n        Math.floor(options.octaves) !== options.octaves)\n    ) {\n      throw new Error('options.octaves must be an integer');\n    }\n\n    if (options['persistence'] && typeof options.persistence !== 'number') {\n      throw new Error('options.persistence must be a number');\n    }\n\n    if (options['random'] && typeof options.random !== 'function') {\n      throw new Error('options.random must be a function');\n    }\n\n    if (options['min'] && typeof options.min !== 'number') {\n      throw new Error('options.min must be a number');\n    }\n\n    if (options['max'] && typeof options.max !== 'number') {\n      throw new Error('options.max must be a number');\n    }\n  }\n\n  const optionsResult = {\n    amplitude: 1.0,\n    frequency: 1.0,\n    max: 1.0,\n    min: -1.0,\n    octaves: 1,\n    persistence: 0.5,\n    random: Math.random,\n    ...options,\n  };\n  if (optionsResult.min > optionsResult.max) {\n    throw new Error('min must be smaller max');\n  }\n  return optionsResult;\n}\n"]}

package/{esm2020 → esm2022}/lib/ws-thanos-options.token.mjs

@@ -1,13 +1,13 @@
-import { InjectionToken } from '@angular/core';
-import { createWsThanosOptions } from './create-ws-thanos-options';
-export const WS_THANOS_OPTIONS_TOKEN = new InjectionToken('thanosOptions', {
-    providedIn: 'root',
-    factory: () => createWsThanosOptions(),
-});
-export function provideWsThanosOptions(options) {
-    return {
-        provide: WS_THANOS_OPTIONS_TOKEN,
-        useValue: createWsThanosOptions(options),
-    };
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtdGhhbm9zLW9wdGlvbnMudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3B1YmxpYy93cy10aGFub3Mvc3JjL2xpYi93cy10aGFub3Mtb3B0aW9ucy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3pELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBR25FLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLElBQUksY0FBYyxDQUN2RCxlQUFlLEVBQ2Y7SUFDRSxVQUFVLEVBQUUsTUFBTTtJQUNsQixPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMscUJBQXFCLEVBQUU7Q0FDdkMsQ0FDRixDQUFDO0FBRUYsTUFBTSxVQUFVLHNCQUFzQixDQUNwQyxPQUFrQztJQUVsQyxPQUFPO1FBQ0wsT0FBTyxFQUFFLHVCQUF1QjtRQUNoQyxRQUFRLEVBQUUscUJBQXFCLENBQUMsT0FBTyxDQUFDO0tBQ3pDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBjcmVhdGVXc1RoYW5vc09wdGlvbnMgfSBmcm9tICcuL2NyZWF0ZS13cy10aGFub3Mtb3B0aW9ucyc7XG5pbXBvcnQgdHlwZSB7IFdzVGhhbm9zT3B0aW9ucyB9IGZyb20gJy4vd3MtdGhhbm9zLm9wdGlvbnMnO1xuXG5leHBvcnQgY29uc3QgV1NfVEhBTk9TX09QVElPTlNfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW48V3NUaGFub3NPcHRpb25zPihcbiAgJ3RoYW5vc09wdGlvbnMnLFxuICB7XG4gICAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICAgIGZhY3Rvcnk6ICgpID0+IGNyZWF0ZVdzVGhhbm9zT3B0aW9ucygpLFxuICB9XG4pO1xuXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZVdzVGhhbm9zT3B0aW9ucyhcbiAgb3B0aW9ucz86IFBhcnRpYWw8V3NUaGFub3NPcHRpb25zPlxuKTogUHJvdmlkZXIge1xuICByZXR1cm4ge1xuICAgIHByb3ZpZGU6IFdTX1RIQU5PU19PUFRJT05TX1RPS0VOLFxuICAgIHVzZVZhbHVlOiBjcmVhdGVXc1RoYW5vc09wdGlvbnMob3B0aW9ucyksXG4gIH07XG59XG4iXX0=
+import { InjectionToken } from '@angular/core';
+import { createWsThanosOptions } from './create-ws-thanos-options';
+export const WS_THANOS_OPTIONS_TOKEN = new InjectionToken('thanosOptions', {
+    providedIn: 'root',
+    factory: () => createWsThanosOptions(),
+});
+export function provideWsThanosOptions(options) {
+    return {
+        provide: WS_THANOS_OPTIONS_TOKEN,
+        useValue: createWsThanosOptions(options),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtdGhhbm9zLW9wdGlvbnMudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3B1YmxpYy93cy10aGFub3Mvc3JjL2xpYi93cy10aGFub3Mtb3B0aW9ucy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3pELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBR25FLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLElBQUksY0FBYyxDQUFrQixlQUFlLEVBQUU7SUFDMUYsVUFBVSxFQUFFLE1BQU07SUFDbEIsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLHFCQUFxQixFQUFFO0NBQ3ZDLENBQUMsQ0FBQztBQUVILE1BQU0sVUFBVSxzQkFBc0IsQ0FBQyxPQUFrQztJQUN2RSxPQUFPO1FBQ0wsT0FBTyxFQUFFLHVCQUF1QjtRQUNoQyxRQUFRLEVBQUUscUJBQXFCLENBQUMsT0FBTyxDQUFDO0tBQ3pDLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBjcmVhdGVXc1RoYW5vc09wdGlvbnMgfSBmcm9tICcuL2NyZWF0ZS13cy10aGFub3Mtb3B0aW9ucyc7XG5pbXBvcnQgdHlwZSB7IFdzVGhhbm9zT3B0aW9ucyB9IGZyb20gJy4vd3MtdGhhbm9zLm9wdGlvbnMnO1xuXG5leHBvcnQgY29uc3QgV1NfVEhBTk9TX09QVElPTlNfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW48V3NUaGFub3NPcHRpb25zPigndGhhbm9zT3B0aW9ucycsIHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxuICBmYWN0b3J5OiAoKSA9PiBjcmVhdGVXc1RoYW5vc09wdGlvbnMoKSxcbn0pO1xuXG5leHBvcnQgZnVuY3Rpb24gcHJvdmlkZVdzVGhhbm9zT3B0aW9ucyhvcHRpb25zPzogUGFydGlhbDxXc1RoYW5vc09wdGlvbnM+KTogUHJvdmlkZXIge1xuICByZXR1cm4ge1xuICAgIHByb3ZpZGU6IFdTX1RIQU5PU19PUFRJT05TX1RPS0VOLFxuICAgIHVzZVZhbHVlOiBjcmVhdGVXc1RoYW5vc09wdGlvbnMob3B0aW9ucyksXG4gIH07XG59XG4iXX0=

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

@@ -0,0 +1,62 @@
+import { Directive, ElementRef, EventEmitter, Inject, NgZone, Output } from '@angular/core';
+import { WS_THANOS_OPTIONS_TOKEN } from './ws-thanos-options.token';
+import { WsThanosService } from './ws-thanos.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./ws-thanos.service";
+class WsThanosDirective {
+    vaporizeDomElem;
+    thanosService;
+    thanosOptions;
+    ngZone;
+    subscription;
+    wsThanosComplete = new EventEmitter();
+    constructor(vaporizeDomElem, thanosService, thanosOptions, ngZone) {
+        this.vaporizeDomElem = vaporizeDomElem;
+        this.thanosService = thanosService;
+        this.thanosOptions = thanosOptions;
+        this.ngZone = ngZone;
+    }
+    vaporize(removeElem = true) {
+        const elem = this.vaporizeDomElem.nativeElement;
+        this.subscription = this.thanosService.vaporize(elem).subscribe({
+            complete: () => {
+                this.ngZone.run(() => {
+                    if (removeElem) {
+                        elem.remove();
+                    }
+                    else {
+                        // make visible again
+                        elem.style.transition = 'opacity 700ms';
+                        elem.style.opacity = '1';
+                    }
+                    this.wsThanosComplete.emit();
+                });
+            },
+            error: (error) => {
+                console.error('error emitted by vaporize', error);
+                this.wsThanosComplete.emit();
+            },
+        });
+        return this.wsThanosComplete.asObservable();
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsThanosDirective, deps: [{ token: i0.ElementRef }, { token: i1.WsThanosService }, { token: WS_THANOS_OPTIONS_TOKEN }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: WsThanosDirective, isStandalone: true, selector: "[wsThanos], ws-thanos", outputs: { wsThanosComplete: "wsThanosComplete" }, exportAs: ["thanos"], ngImport: i0 });
+}
+export { WsThanosDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: WsThanosDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[wsThanos], ws-thanos',
+                    exportAs: 'thanos',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.WsThanosService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WS_THANOS_OPTIONS_TOKEN]
+                }] }, { type: i0.NgZone }]; }, propDecorators: { wsThanosComplete: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/ws-thanos.options.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtdGhhbm9zLm9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3B1YmxpYy93cy10aGFub3Mvc3JjL2xpYi93cy10aGFub3Mub3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBXc1RoYW5vc09wdGlvbnMge1xuICBhbmltYXRpb25MZW5ndGg6IG51bWJlcjtcbiAgbWF4UGFydGljbGVDb3VudDogbnVtYmVyO1xuICBwYXJ0aWNsZUFjY2VsZXJhdGlvbjogbnVtYmVyO1xufVxuIl19