@tsparticles/fireworks 3.0.0-beta.0

package/cjs/fireworks.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fireworks = void 0;
+const engine_1 = require("@tsparticles/engine");
+const FireworkOptions_1 = require("./FireworkOptions");
+const basic_1 = require("@tsparticles/basic");
+const updater_destroy_1 = require("@tsparticles/updater-destroy");
+const plugin_emitters_1 = require("@tsparticles/plugin-emitters");
+const updater_life_1 = require("@tsparticles/updater-life");
+const shape_line_1 = require("@tsparticles/shape-line");
+const updater_rotate_1 = require("@tsparticles/updater-rotate");
+const plugin_sounds_1 = require("@tsparticles/plugin-sounds");
+const updater_stroke_color_1 = require("@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 (0, plugin_emitters_1.loadEmittersPlugin)(engine_1.tsParticles, false);
+    await (0, plugin_sounds_1.loadSoundsPlugin)(engine_1.tsParticles, false);
+    await (0, shape_line_1.loadLineShape)(engine_1.tsParticles, false);
+    await (0, updater_rotate_1.loadRotateUpdater)(engine_1.tsParticles, false);
+    await (0, updater_destroy_1.loadDestroyUpdater)(engine_1.tsParticles, false);
+    await (0, updater_life_1.loadLifeUpdater)(engine_1.tsParticles, false);
+    await (0, updater_stroke_color_1.loadStrokeColorUpdater)(engine_1.tsParticles, false);
+    await (0, basic_1.loadBasic)(engine_1.tsParticles, false);
+    initializing = false;
+    initialized = true;
+}
+async function fireworks(idOrOptions, sourceOptions) {
+    await initPlugins();
+    let id;
+    const options = new FireworkOptions_1.FireworkOptions();
+    if ((0, engine_1.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: (0, engine_1.isNumber)(options.rate)
+                    ? 1 / options.rate
+                    : { min: 1 / (0, engine_1.getRangeMin)(options.rate), max: 1 / (0, engine_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: (0, engine_1.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: (0, engine_1.setRangeValue)(options.gravity),
+                            },
+                            speed: (0, engine_1.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 engine_1.tsParticles.load({ id, options: particlesOptions });
+    if (!container) {
+        return;
+    }
+    return new FireworksInstance(container);
+}
+exports.fireworks = fireworks;
+fireworks.version = engine_1.tsParticles.version;
+if (!(0, engine_1.isSsr)()) {
+    window.fireworks = fireworks;
+}

package/cjs/index.js

@@ -0,0 +1,17 @@
+"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("./fireworks"), exports);

package/esm/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/esm/IFireworkOptions.js

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

package/esm/bundle.js

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

package/esm/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/esm/index.js

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