@tsparticles/plugin-emitters 3.0.0-alpha.0

package/esm/Options/Classes/Emitter.js

@@ -0,0 +1,62 @@
+import { AnimatableColor, deepExtend, executeOnSingleOrMultiple, setRangeValue } from "@tsparticles/engine";
+import { EmitterLife } from "./EmitterLife";
+import { EmitterRate } from "./EmitterRate";
+import { EmitterSize } from "./EmitterSize";
+export class Emitter {
+    constructor() {
+        this.autoPlay = true;
+        this.fill = true;
+        this.life = new EmitterLife();
+        this.rate = new EmitterRate();
+        this.shape = "square";
+        this.startCount = 0;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.autoPlay !== undefined) {
+            this.autoPlay = data.autoPlay;
+        }
+        if (data.size !== undefined) {
+            if (this.size === undefined) {
+                this.size = new EmitterSize();
+            }
+            this.size.load(data.size);
+        }
+        if (data.direction !== undefined) {
+            this.direction = data.direction;
+        }
+        this.domId = data.domId;
+        if (data.fill !== undefined) {
+            this.fill = data.fill;
+        }
+        this.life.load(data.life);
+        this.name = data.name;
+        this.particles = executeOnSingleOrMultiple(data.particles, (particles) => {
+            return deepExtend({}, particles);
+        });
+        this.rate.load(data.rate);
+        if (data.shape !== undefined) {
+            this.shape = data.shape;
+        }
+        if (data.position !== undefined) {
+            this.position = {};
+            if (data.position.x !== undefined) {
+                this.position.x = setRangeValue(data.position.x);
+            }
+            if (data.position.y !== undefined) {
+                this.position.y = setRangeValue(data.position.y);
+            }
+        }
+        if (data.spawnColor !== undefined) {
+            if (this.spawnColor === undefined) {
+                this.spawnColor = new AnimatableColor();
+            }
+            this.spawnColor.load(data.spawnColor);
+        }
+        if (data.startCount !== undefined) {
+            this.startCount = data.startCount;
+        }
+    }
+}

package/esm/Options/Classes/EmitterLife.js

@@ -0,0 +1,22 @@
+export class EmitterLife {
+    constructor() {
+        this.wait = false;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.count !== undefined) {
+            this.count = data.count;
+        }
+        if (data.delay !== undefined) {
+            this.delay = data.delay;
+        }
+        if (data.duration !== undefined) {
+            this.duration = data.duration;
+        }
+        if (data.wait !== undefined) {
+            this.wait = data.wait;
+        }
+    }
+}

package/esm/Options/Classes/EmitterRate.js

@@ -0,0 +1,18 @@
+import { setRangeValue } from "@tsparticles/engine";
+export class EmitterRate {
+    constructor() {
+        this.quantity = 1;
+        this.delay = 0.1;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.quantity !== undefined) {
+            this.quantity = setRangeValue(data.quantity);
+        }
+        if (data.delay !== undefined) {
+            this.delay = setRangeValue(data.delay);
+        }
+    }
+}

package/esm/Options/Classes/EmitterSize.js

@@ -0,0 +1,21 @@
+export class EmitterSize {
+    constructor() {
+        this.mode = "percent";
+        this.height = 0;
+        this.width = 0;
+    }
+    load(data) {
+        if (data === undefined) {
+            return;
+        }
+        if (data.mode !== undefined) {
+            this.mode = data.mode;
+        }
+        if (data.height !== undefined) {
+            this.height = data.height;
+        }
+        if (data.width !== undefined) {
+            this.width = data.width;
+        }
+    }
+}

package/esm/Options/Interfaces/IEmitter.js

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

package/esm/Options/Interfaces/IEmitterLife.js

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

package/esm/Options/Interfaces/IEmitterRate.js

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

package/esm/Options/Interfaces/IEmitterSize.js

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

package/esm/ShapeManager.js

@@ -0,0 +1,17 @@
+const shapes = new Map();
+export class ShapeManager {
+    constructor(engine) {
+        this._engine = engine;
+    }
+    addShape(name, drawer) {
+        if (!this.getShape(name)) {
+            shapes.set(name, drawer);
+        }
+    }
+    getShape(name) {
+        return shapes.get(name);
+    }
+    getSupportedShapes() {
+        return shapes.keys();
+    }
+}

package/esm/Shapes/Circle/CircleShape.js

@@ -0,0 +1,24 @@
+import { getRandom } from "@tsparticles/engine";
+export class CircleShape {
+    randomPosition(position, size, fill) {
+        const generateTheta = (x, y) => {
+            const u = getRandom() / 4.0, theta = Math.atan((y / x) * Math.tan(2 * Math.PI * u)), v = getRandom();
+            if (v < 0.25) {
+                return theta;
+            }
+            else if (v < 0.5) {
+                return Math.PI - theta;
+            }
+            else if (v < 0.75) {
+                return Math.PI + theta;
+            }
+            else {
+                return -theta;
+            }
+        }, radius = (x, y, theta) => (x * y) / Math.sqrt((y * Math.cos(theta)) ** 2 + (x * Math.sin(theta)) ** 2), [a, b] = [size.width / 2, size.height / 2], randomTheta = generateTheta(a, b), maxRadius = radius(a, b, randomTheta), randomRadius = fill ? maxRadius * Math.sqrt(getRandom()) : maxRadius;
+        return {
+            x: position.x + randomRadius * Math.cos(randomTheta),
+            y: position.y + randomRadius * Math.sin(randomTheta),
+        };
+    }
+}

package/esm/Shapes/Square/SquareShape.js

@@ -0,0 +1,40 @@
+import { getRandom } from "@tsparticles/engine";
+function randomSquareCoordinate(position, offset) {
+    return position + offset * (getRandom() - 0.5);
+}
+export class SquareShape {
+    randomPosition(position, size, fill) {
+        if (fill) {
+            return {
+                x: randomSquareCoordinate(position.x, size.width),
+                y: randomSquareCoordinate(position.y, size.height),
+            };
+        }
+        else {
+            const halfW = size.width / 2, halfH = size.height / 2, side = Math.floor(getRandom() * 4), v = (getRandom() - 0.5) * 2;
+            switch (side) {
+                case 0:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y - halfH,
+                    };
+                case 1:
+                    return {
+                        x: position.x - halfW,
+                        y: position.y + v * halfH,
+                    };
+                case 2:
+                    return {
+                        x: position.x + v * halfW,
+                        y: position.y + halfH,
+                    };
+                case 3:
+                default:
+                    return {
+                        x: position.x + halfW,
+                        y: position.y + v * halfH,
+                    };
+            }
+        }
+    }
+}

package/esm/index.js

@@ -0,0 +1,113 @@
+import { executeOnSingleOrMultiple, isInArray } from "@tsparticles/engine";
+import { CircleShape } from "./Shapes/Circle/CircleShape";
+import { Emitter } from "./Options/Classes/Emitter";
+import { Emitters } from "./Emitters";
+import { ShapeManager } from "./ShapeManager";
+import { SquareShape } from "./Shapes/Square/SquareShape";
+class EmittersPlugin {
+    constructor(engine) {
+        this._engine = engine;
+        this.id = "emitters";
+    }
+    getPlugin(container) {
+        return new Emitters(this._engine, container);
+    }
+    loadOptions(options, source) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
+            return;
+        }
+        if (source === null || source === void 0 ? void 0 : source.emitters) {
+            options.emitters = executeOnSingleOrMultiple(source.emitters, (emitter) => {
+                const tmp = new Emitter();
+                tmp.load(emitter);
+                return tmp;
+            });
+        }
+        const interactivityEmitters = (_b = (_a = source === null || source === void 0 ? void 0 : source.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.emitters;
+        if (interactivityEmitters) {
+            if (interactivityEmitters instanceof Array) {
+                options.interactivity.modes.emitters = {
+                    random: {
+                        count: 1,
+                        enable: true,
+                    },
+                    value: interactivityEmitters.map((s) => {
+                        const tmp = new Emitter();
+                        tmp.load(s);
+                        return tmp;
+                    }),
+                };
+            }
+            else {
+                const emitterMode = interactivityEmitters;
+                if (emitterMode.value !== undefined) {
+                    if (emitterMode.value instanceof Array) {
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_c = emitterMode.random.count) !== null && _c !== void 0 ? _c : 1,
+                                enable: (_d = emitterMode.random.enable) !== null && _d !== void 0 ? _d : false,
+                            },
+                            value: emitterMode.value.map((s) => {
+                                const tmp = new Emitter();
+                                tmp.load(s);
+                                return tmp;
+                            }),
+                        };
+                    }
+                    else {
+                        const tmp = new Emitter();
+                        tmp.load(emitterMode.value);
+                        options.interactivity.modes.emitters = {
+                            random: {
+                                count: (_e = emitterMode.random.count) !== null && _e !== void 0 ? _e : 1,
+                                enable: (_f = emitterMode.random.enable) !== null && _f !== void 0 ? _f : false,
+                            },
+                            value: tmp,
+                        };
+                    }
+                }
+                else {
+                    const emitterOptions = (options.interactivity.modes.emitters = {
+                        random: {
+                            count: 1,
+                            enable: false,
+                        },
+                        value: new Emitter(),
+                    });
+                    emitterOptions.value.load(interactivityEmitters);
+                }
+            }
+        }
+    }
+    needsPlugin(options) {
+        var _a, _b, _c;
+        if (!options) {
+            return false;
+        }
+        const emitters = options.emitters;
+        return ((emitters instanceof Array && !!emitters.length) ||
+            emitters !== undefined ||
+            (!!((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
+                isInArray("emitter", options.interactivity.events.onClick.mode)));
+    }
+}
+export async function loadEmittersPlugin(engine) {
+    if (!engine.emitterShapeManager) {
+        engine.emitterShapeManager = new ShapeManager(engine);
+    }
+    if (!engine.addEmitterShape) {
+        engine.addEmitterShape = (name, shape) => {
+            var _a;
+            (_a = engine.emitterShapeManager) === null || _a === void 0 ? void 0 : _a.addShape(name, shape);
+        };
+    }
+    const plugin = new EmittersPlugin(engine);
+    await engine.addPlugin(plugin);
+    engine.addEmitterShape("circle", new CircleShape());
+    engine.addEmitterShape("square", new SquareShape());
+}
+export * from "./EmitterContainer";
+export * from "./EmittersEngine";
+export * from "./Enums/EmitterClickMode";
+export * from "./Enums/EmitterShapeType";

package/esm/types.js

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

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@tsparticles/plugin-emitters",
+  "version": "3.0.0-alpha.0",
+  "description": "tsParticles emitters plugin",
+  "homepage": "https://particles.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matteobruni/tsparticles.git",
+    "directory": "plugins/emitters"
+  },
+  "keywords": [
+    "front-end",
+    "frontend",
+    "tsparticles",
+    "particles.js",
+    "particlesjs",
+    "particles",
+    "particle",
+    "canvas",
+    "jsparticles",
+    "xparticles",
+    "particles-js",
+    "particles-bg",
+    "particles-bg-vue",
+    "particles-ts",
+    "particles.ts",
+    "react-particles-js",
+    "react-particles.js",
+    "react-particles",
+    "react",
+    "reactjs",
+    "vue-particles",
+    "ngx-particles",
+    "angular-particles",
+    "particleground",
+    "vue",
+    "vuejs",
+    "preact",
+    "preactjs",
+    "jquery",
+    "angularjs",
+    "angular",
+    "typescript",
+    "javascript",
+    "animation",
+    "web",
+    "html5",
+    "web-design",
+    "webdesign",
+    "css",
+    "html",
+    "css3",
+    "animated",
+    "background",
+    "confetti",
+    "canvas",
+    "fireworks",
+    "fireworks-js",
+    "confetti-js",
+    "confettijs",
+    "fireworksjs",
+    "canvas-confetti",
+    "@tsparticles/plugin"
+  ],
+  "author": "Matteo Bruni <matteo.bruni@me.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/matteobruni/tsparticles/issues"
+  },
+  "main": "cjs/index.js",
+  "jsdelivr": "tsparticles.plugin.emitters.min.js",
+  "unpkg": "tsparticles.plugin.emitters.min.js",
+  "module": "esm/index.js",
+  "types": "types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tsparticles/engine": "^3.0.0-alpha.0"
+  }
+}