@tsparticles/fireworks 3.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matteo Bruni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+[![banner](https://particles.js.org/images/banner2.png)](https://particles.js.org)
+
+# tsParticles Fireworks Bundle
+
+[![jsDelivr](https://data.jsdelivr.com/v1/package/npm/@tsparticles/fireworks/badge)](https://www.jsdelivr.com/package/npm/@tsparticles/fireworks) [![npmjs](https://badge.fury.io/js/@tsparticles/fireworks.svg)](https://www.npmjs.com/package/@tsparticles/fireworks) [![npmjs](https://img.shields.io/npm/dt/@tsparticles/fireworks)](https://www.npmjs.com/package/@tsparticles/fireworks) [![GitHub Sponsors](https://img.shields.io/github/sponsors/matteobruni)](https://github.com/sponsors/matteobruni)
+
+[tsParticles](https://github.com/matteobruni/tsparticles) fireworks bundle loads all the features necessary to create
+beautiful fireworks effects with ease.
+
+**Included Packages**
+
+- [@tsparticles/engine](https://github.com/matteobruni/tsparticles/tree/main/engine)
+- [@tsparticles/move-base](https://github.com/matteobruni/tsparticles/tree/main/move/base)
+- [@tsparticles/plugin-emitters](https://github.com/matteobruni/tsparticles/tree/main/plugins/emitters)
+- [@tsparticles/plugin-sounds](https://github.com/matteobruni/tsparticles/tree/main/plugins/sounds)
+- [@tsparticles/shape-circle](https://github.com/matteobruni/tsparticles/tree/main/shapes/circle)
+- [@tsparticles/shape-line](https://github.com/matteobruni/tsparticles/tree/main/shapes/line)
+- [@tsparticles/updater-color](https://github.com/matteobruni/tsparticles/tree/main/updaters/color)
+- [@tsparticles/updater-destroy](https://github.com/matteobruni/tsparticles/tree/main/updaters/destroy)
+- [@tsparticles/updater-life](https://github.com/matteobruni/tsparticles/tree/main/updaters/life)
+- [@tsparticles/updater-opacity](https://github.com/matteobruni/tsparticles/tree/main/updaters/opacity)
+- [@tsparticles/updater-out-modes](https://github.com/matteobruni/tsparticles/tree/main/updaters/outModes)
+- [@tsparticles/updater-rotate](https://github.com/matteobruni/tsparticles/tree/main/updaters/rotate)
+- [@tsparticles/updater-size](https://github.com/matteobruni/tsparticles/tree/main/updaters/size)
+- [@tsparticles/updater-stroke-color](https://github.com/matteobruni/tsparticles/tree/main/updaters/strokeColor)
+
+## How to use it
+
+### CDN / Vanilla JS / jQuery
+
+The CDN/Vanilla version JS has two different files:
+
+- One is a bundle file with all the scripts included in a single file
+- One is a file including just the `fireworks` function to load the tsParticles fireworks bunddle, all dependencies must
+  be
+  included manually
+
+#### Bundle
+
+Including the `tsparticles.fireworks.bundle.min.js` file will out of the box.
+
+This is the easiest usage, since it's a single file with all the features loaded.
+
+You can still add additional packages, loading them like all the other packages.
+
+#### Not Bundle
+
+This installation requires more work since all dependencies must be included in the page. Some lines above are all
+specified in the **Included Packages** section.
+
+### Usage
+
+Once the scripts are loaded you can set up `tsParticles` like the following examples:
+
+** Easiest Way **
+
+```javascript
+fireworks();
+```
+
+** Async Way, best practice **
+
+```javascript
+(async () => {
+  await fireworks();
+})();
+```
+
+** Fireworks Options **
+
+```javascript
+fireworks({
+  colors: ["#ffffff", "#ff0000"],
+});
+```
+
+#### Options
+
+The `fireworks` has only a single `options` object parameter, with the following properties:
+
+- `brightness` Number or { min: number; max: number; }: The brightness offset applied to the particles color, from -100
+  to 100.
+- `colors` String or _Array<String>_: An array of color strings, in the HEX format... you know, like `#bada55`.
+- `gravity` Number or { min: number; max: number; }: The gravity applied to the fireworks particles.
+- `minHeight` Number or { min: number; max: number; }: The minimum height for fireworks explosions (the lesser, the
+  higher).
+- `rate` Number or { min: number; max: number; }: The rate of the fireworks explosions.
+- `saturation` Number or { min: number; max: number; }: The saturation offset applied to the particles color, from -100
+  to 100.
+- `sounds` Boolean: Whether to play sounds or not.
+- `speed` Number or { min: number; max: number; }: The speed of the fireworks particles.
+- `splitCount` Number or { min: number; max: number; }: The number of particles to split the emitter in.

package/browser/FireworkOptions.js

@@ -0,0 +1,63 @@
+import { isArray, setRangeValue, } from "@tsparticles/engine";
+export class FireworkOptions {
+    constructor() {
+        this.brightness = {
+            min: -30,
+            max: 30,
+        };
+        this.colors = ["#ff595e", "#ffca3a", "#8ac926", "#1982c4", "#6a4c93"];
+        this.gravity = 5;
+        this.minHeight = {
+            min: 10,
+            max: 30,
+        };
+        this.rate = 20;
+        this.saturation = {
+            min: -30,
+            max: 30,
+        };
+        this.sounds = true;
+        this.speed = { min: 5, max: 15 };
+        this.splitCount = {
+            min: 75,
+            max: 150,
+        };
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.colors !== undefined) {
+            if (isArray(data.colors)) {
+                this.colors = [...data.colors];
+            }
+            else {
+                this.colors = data.colors;
+            }
+        }
+        if (data.brightness !== undefined) {
+            this.brightness = setRangeValue(data.brightness);
+        }
+        if (data.gravity !== undefined) {
+            this.gravity = setRangeValue(data.gravity);
+        }
+        if (data.minHeight !== undefined) {
+            this.minHeight = setRangeValue(data.minHeight);
+        }
+        if (data.rate !== undefined) {
+            this.rate = setRangeValue(data.rate);
+        }
+        if (data.saturation !== undefined) {
+            this.saturation = setRangeValue(data.saturation);
+        }
+        if (data.sounds !== undefined) {
+            this.sounds = data.sounds;
+        }
+        if (data.speed !== undefined) {
+            this.speed = setRangeValue(data.speed);
+        }
+        if (data.splitCount !== undefined) {
+            this.splitCount = setRangeValue(data.splitCount);
+        }
+    }
+}

package/browser/IFireworkOptions.js

@@ -0,0 +1 @@
+export {};

package/browser/bundle.js

@@ -0,0 +1,2 @@
+export * from ".";
+export * from "@tsparticles/engine";

package/browser/fireworks.js

@@ -0,0 +1,264 @@
+import { getRangeMax, getRangeMin, isNumber, isSsr, isString, setRangeValue, tsParticles, } from "@tsparticles/engine";
+import { FireworkOptions } from "./FireworkOptions";
+import { loadBasic } from "@tsparticles/basic";
+import { loadDestroyUpdater } from "@tsparticles/updater-destroy";
+import { loadEmittersPlugin } from "@tsparticles/plugin-emitters";
+import { loadLifeUpdater } from "@tsparticles/updater-life";
+import { loadLineShape } from "@tsparticles/shape-line";
+import { loadRotateUpdater } from "@tsparticles/updater-rotate";
+import { loadSoundsPlugin } from "@tsparticles/plugin-sounds";
+import { loadStrokeColorUpdater } from "@tsparticles/updater-stroke-color";
+let initialized = false;
+let initializing = false;
+const explodeSoundCheck = (args) => {
+    const data = args.data;
+    return data.particle.shape === "line";
+};
+class FireworksInstance {
+    constructor(container) {
+        this._container = container;
+    }
+    pause() {
+        this._container.pause();
+    }
+    play() {
+        this._container.play();
+    }
+    stop() {
+        this._container.stop();
+    }
+}
+async function initPlugins() {
+    if (initialized) {
+        return;
+    }
+    if (initializing) {
+        return new Promise((resolve) => {
+            const interval = setInterval(() => {
+                if (!initialized) {
+                    return;
+                }
+                clearInterval(interval);
+                resolve();
+            }, 100);
+        });
+    }
+    initializing = true;
+    await loadEmittersPlugin(tsParticles, false);
+    await loadSoundsPlugin(tsParticles, false);
+    await loadLineShape(tsParticles, false);
+    await loadRotateUpdater(tsParticles, false);
+    await loadDestroyUpdater(tsParticles, false);
+    await loadLifeUpdater(tsParticles, false);
+    await loadStrokeColorUpdater(tsParticles, false);
+    await loadBasic(tsParticles, false);
+    initializing = false;
+    initialized = true;
+}
+export async function fireworks(idOrOptions, sourceOptions) {
+    await initPlugins();
+    let id;
+    const options = new FireworkOptions();
+    if (isString(idOrOptions)) {
+        id = idOrOptions;
+        options.load(sourceOptions);
+    }
+    else {
+        id = "fireworks";
+        options.load(idOrOptions);
+    }
+    const particlesOptions = {
+        detectRetina: true,
+        background: {
+            color: "#000",
+        },
+        fpsLimit: 120,
+        emitters: {
+            direction: "top",
+            life: {
+                count: 0,
+                duration: 0.1,
+                delay: 0.1,
+            },
+            rate: {
+                delay: isNumber(options.rate)
+                    ? 1 / options.rate
+                    : { min: 1 / getRangeMin(options.rate), max: 1 / getRangeMax(options.rate) },
+                quantity: 1,
+            },
+            size: {
+                width: 100,
+                height: 0,
+            },
+            position: {
+                y: 100,
+                x: 50,
+            },
+        },
+        particles: {
+            number: {
+                value: 0,
+            },
+            color: {
+                value: options.colors,
+            },
+            destroy: {
+                mode: "split",
+                bounds: {
+                    top: setRangeValue(options.minHeight),
+                },
+                split: {
+                    sizeOffset: false,
+                    count: 1,
+                    factor: {
+                        value: 0.333333,
+                    },
+                    rate: {
+                        value: options.splitCount,
+                    },
+                    colorOffset: {
+                        s: options.saturation,
+                        l: options.brightness,
+                    },
+                    particles: {
+                        stroke: {
+                            width: 0,
+                        },
+                        number: {
+                            value: 0,
+                        },
+                        opacity: {
+                            value: {
+                                min: 0.1,
+                                max: 1,
+                            },
+                            animation: {
+                                enable: true,
+                                speed: 0.7,
+                                sync: false,
+                                startValue: "max",
+                                destroy: "min",
+                            },
+                        },
+                        shape: {
+                            type: "circle",
+                        },
+                        size: {
+                            value: { min: 1, max: 2 },
+                            animation: {
+                                enable: true,
+                                speed: 5,
+                                count: 1,
+                                sync: false,
+                                startValue: "min",
+                                destroy: "none",
+                            },
+                        },
+                        life: {
+                            count: 1,
+                            duration: {
+                                value: {
+                                    min: 0.25,
+                                    max: 0.5,
+                                },
+                            },
+                        },
+                        move: {
+                            decay: { min: 0.05, max: 0.1 },
+                            enable: true,
+                            gravity: {
+                                enable: true,
+                                inverse: false,
+                                acceleration: setRangeValue(options.gravity),
+                            },
+                            speed: setRangeValue(options.speed),
+                            direction: "none",
+                            outModes: "destroy",
+                        },
+                    },
+                },
+            },
+            life: {
+                count: 1,
+            },
+            shape: {
+                type: "line",
+                options: {
+                    line: {
+                        cap: "round",
+                    },
+                },
+            },
+            size: {
+                value: {
+                    min: 0.1,
+                    max: 50,
+                },
+                animation: {
+                    enable: true,
+                    sync: true,
+                    speed: 90,
+                    startValue: "max",
+                    destroy: "min",
+                },
+            },
+            stroke: {
+                color: {
+                    value: "#ffffff",
+                },
+                width: 0.5,
+            },
+            rotate: {
+                path: true,
+            },
+            move: {
+                enable: true,
+                gravity: {
+                    acceleration: 15,
+                    enable: true,
+                    inverse: true,
+                    maxSpeed: 100,
+                },
+                speed: {
+                    min: 10,
+                    max: 20,
+                },
+                outModes: {
+                    default: "destroy",
+                    top: "none",
+                },
+                trail: {
+                    fill: {
+                        color: "#000",
+                    },
+                    enable: true,
+                    length: 10,
+                },
+            },
+        },
+        sounds: {
+            enable: options.sounds,
+            events: [
+                {
+                    event: "particleRemoved",
+                    filter: explodeSoundCheck,
+                    audio: [
+                        "https://particles.js.org/audio/explosion0.mp3",
+                        "https://particles.js.org/audio/explosion1.mp3",
+                        "https://particles.js.org/audio/explosion2.mp3",
+                    ],
+                },
+            ],
+            volume: 50,
+        },
+    };
+    const container = await tsParticles.load({ id, options: particlesOptions });
+    if (!container) {
+        return;
+    }
+    return new FireworksInstance(container);
+}
+fireworks.version = tsParticles.version;
+if (!isSsr()) {
+    window.fireworks = fireworks;
+}

package/browser/index.js

@@ -0,0 +1 @@
+export * from "./fireworks";

package/cjs/FireworkOptions.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FireworkOptions = void 0;
+const engine_1 = require("@tsparticles/engine");
+class FireworkOptions {
+    constructor() {
+        this.brightness = {
+            min: -30,
+            max: 30,
+        };
+        this.colors = ["#ff595e", "#ffca3a", "#8ac926", "#1982c4", "#6a4c93"];
+        this.gravity = 5;
+        this.minHeight = {
+            min: 10,
+            max: 30,
+        };
+        this.rate = 20;
+        this.saturation = {
+            min: -30,
+            max: 30,
+        };
+        this.sounds = true;
+        this.speed = { min: 5, max: 15 };
+        this.splitCount = {
+            min: 75,
+            max: 150,
+        };
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.colors !== undefined) {
+            if ((0, engine_1.isArray)(data.colors)) {
+                this.colors = [...data.colors];
+            }
+            else {
+                this.colors = data.colors;
+            }
+        }
+        if (data.brightness !== undefined) {
+            this.brightness = (0, engine_1.setRangeValue)(data.brightness);
+        }
+        if (data.gravity !== undefined) {
+            this.gravity = (0, engine_1.setRangeValue)(data.gravity);
+        }
+        if (data.minHeight !== undefined) {
+            this.minHeight = (0, engine_1.setRangeValue)(data.minHeight);
+        }
+        if (data.rate !== undefined) {
+            this.rate = (0, engine_1.setRangeValue)(data.rate);
+        }
+        if (data.saturation !== undefined) {
+            this.saturation = (0, engine_1.setRangeValue)(data.saturation);
+        }
+        if (data.sounds !== undefined) {
+            this.sounds = data.sounds;
+        }
+        if (data.speed !== undefined) {
+            this.speed = (0, engine_1.setRangeValue)(data.speed);
+        }
+        if (data.splitCount !== undefined) {
+            this.splitCount = (0, engine_1.setRangeValue)(data.splitCount);
+        }
+    }
+}
+exports.FireworkOptions = FireworkOptions;

package/cjs/IFireworkOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/bundle.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("."), exports);
+__exportStar(require("@tsparticles/engine"), exports);