@tsparticles/updater-destroy 3.0.0-alpha.0

package/esm/DestroyUpdater.js

@@ -0,0 +1,125 @@
+import { getRangeValue, getValue, itemFromSingleOrMultiple, loadParticlesOptions, randomInRange, setRangeValue, } from "@tsparticles/engine";
+import { Destroy } from "./Options/Classes/Destroy";
+export class DestroyUpdater {
+    constructor(engine, container) {
+        this.engine = engine;
+        this.container = container;
+    }
+    init(particle) {
+        const container = this.container, particlesOptions = particle.options, destroyOptions = particlesOptions.destroy;
+        if (!destroyOptions) {
+            return;
+        }
+        particle.splitCount = 0;
+        const destroyBounds = destroyOptions.bounds;
+        if (!particle.destroyBounds) {
+            particle.destroyBounds = {};
+        }
+        if (destroyBounds.bottom) {
+            particle.destroyBounds.bottom = (getRangeValue(destroyBounds.bottom) * container.canvas.size.height) / 100;
+        }
+        if (destroyBounds.left) {
+            particle.destroyBounds.left = (getRangeValue(destroyBounds.left) * container.canvas.size.width) / 100;
+        }
+        if (destroyBounds.right) {
+            particle.destroyBounds.right = (getRangeValue(destroyBounds.right) * container.canvas.size.width) / 100;
+        }
+        if (destroyBounds.top) {
+            particle.destroyBounds.top = (getRangeValue(destroyBounds.top) * container.canvas.size.height) / 100;
+        }
+    }
+    isEnabled(particle) {
+        return !particle.destroyed;
+    }
+    loadOptions(options, ...sources) {
+        if (!options.destroy) {
+            options.destroy = new Destroy();
+        }
+        for (const source of sources) {
+            options.destroy.load(source === null || source === void 0 ? void 0 : source.destroy);
+        }
+    }
+    particleDestroyed(particle, override) {
+        if (override) {
+            return;
+        }
+        const destroyOptions = particle.options.destroy;
+        if (destroyOptions && destroyOptions.mode === "split") {
+            this.split(particle);
+        }
+    }
+    update(particle) {
+        if (!this.isEnabled(particle)) {
+            return;
+        }
+        const position = particle.getPosition(), bounds = particle.destroyBounds;
+        if (!bounds) {
+            return;
+        }
+        if ((bounds.bottom !== undefined && position.y >= bounds.bottom) ||
+            (bounds.left !== undefined && position.x <= bounds.left) ||
+            (bounds.right !== undefined && position.x >= bounds.right) ||
+            (bounds.top !== undefined && position.y <= bounds.top)) {
+            particle.destroy();
+        }
+    }
+    addSplitParticle(parent, splitParticlesOptions) {
+        const destroyOptions = parent.options.destroy;
+        if (!destroyOptions) {
+            return;
+        }
+        const splitOptions = destroyOptions.split, options = loadParticlesOptions(this.engine, this.container, parent.options), factor = getValue(splitOptions.factor);
+        options.color.load({
+            value: {
+                hsl: parent.getFillColor(),
+            },
+        });
+        options.move.load({
+            center: {
+                x: parent.position.x,
+                y: parent.position.y,
+                mode: "precise",
+            },
+        });
+        if (typeof options.size.value === "number") {
+            options.size.value /= factor;
+        }
+        else {
+            options.size.value.min /= factor;
+            options.size.value.max /= factor;
+        }
+        options.load(splitParticlesOptions);
+        const offset = splitOptions.sizeOffset ? setRangeValue(-parent.size.value, parent.size.value) : 0, position = {
+            x: parent.position.x + randomInRange(offset),
+            y: parent.position.y + randomInRange(offset),
+        };
+        return this.container.particles.addParticle(position, options, parent.group, (particle) => {
+            var _a;
+            if (particle.size.value < 0.5) {
+                return false;
+            }
+            particle.velocity.length = randomInRange(setRangeValue(parent.velocity.length, particle.velocity.length));
+            particle.splitCount = ((_a = parent.splitCount) !== null && _a !== void 0 ? _a : 0) + 1;
+            particle.unbreakable = true;
+            setTimeout(() => {
+                particle.unbreakable = false;
+            }, 500);
+            return true;
+        });
+    }
+    split(particle) {
+        const destroyOptions = particle.options.destroy;
+        if (!destroyOptions) {
+            return;
+        }
+        const splitOptions = destroyOptions.split;
+        if (splitOptions.count >= 0 &&
+            (particle.splitCount === undefined || particle.splitCount++ > splitOptions.count)) {
+            return;
+        }
+        const rate = getValue(splitOptions.rate), particlesSplitOptions = itemFromSingleOrMultiple(splitOptions.particles);
+        for (let i = 0; i < rate; i++) {
+            this.addSplitParticle(particle, particlesSplitOptions);
+        }
+    }
+}

package/esm/Enums/DestroyMode.js

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

package/esm/Options/Classes/Destroy.js

@@ -0,0 +1,21 @@
+import { DestroyBounds } from "./DestroyBounds";
+import { Split } from "./Split";
+export class Destroy {
+    constructor() {
+        this.bounds = new DestroyBounds();
+        this.mode = "none";
+        this.split = new Split();
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.mode) {
+            this.mode = data.mode;
+        }
+        if (data.bounds) {
+            this.bounds.load(data.bounds);
+        }
+        this.split.load(data.split);
+    }
+}

package/esm/Options/Classes/DestroyBounds.js

@@ -0,0 +1,20 @@
+import { setRangeValue } from "@tsparticles/engine";
+export class DestroyBounds {
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.bottom !== undefined) {
+            this.bottom = setRangeValue(data.bottom);
+        }
+        if (data.left !== undefined) {
+            this.left = setRangeValue(data.left);
+        }
+        if (data.right !== undefined) {
+            this.right = setRangeValue(data.right);
+        }
+        if (data.top !== undefined) {
+            this.top = setRangeValue(data.top);
+        }
+    }
+}

package/esm/Options/Classes/Split.js

@@ -0,0 +1,27 @@
+import { deepExtend, executeOnSingleOrMultiple } from "@tsparticles/engine";
+import { SplitFactor } from "./SplitFactor";
+import { SplitRate } from "./SplitRate";
+export class Split {
+    constructor() {
+        this.count = 1;
+        this.factor = new SplitFactor();
+        this.rate = new SplitRate();
+        this.sizeOffset = true;
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.count !== undefined) {
+            this.count = data.count;
+        }
+        this.factor.load(data.factor);
+        this.rate.load(data.rate);
+        this.particles = executeOnSingleOrMultiple(data.particles, (particles) => {
+            return deepExtend({}, particles);
+        });
+        if (data.sizeOffset !== undefined) {
+            this.sizeOffset = data.sizeOffset;
+        }
+    }
+}

package/esm/Options/Classes/SplitFactor.js

@@ -0,0 +1,7 @@
+import { ValueWithRandom } from "@tsparticles/engine";
+export class SplitFactor extends ValueWithRandom {
+    constructor() {
+        super();
+        this.value = 3;
+    }
+}

package/esm/Options/Classes/SplitRate.js

@@ -0,0 +1,7 @@
+import { ValueWithRandom } from "@tsparticles/engine";
+export class SplitRate extends ValueWithRandom {
+    constructor() {
+        super();
+        this.value = { min: 4, max: 9 };
+    }
+}

package/esm/Options/Interfaces/IDestroy.js

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

package/esm/Options/Interfaces/IDestroyBounds.js

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

package/esm/Options/Interfaces/ISplit.js

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

package/esm/index.js

@@ -0,0 +1,4 @@
+import { DestroyUpdater } from "./DestroyUpdater";
+export async function loadDestroyUpdater(engine) {
+    await engine.addParticleUpdater("destroy", (container) => new DestroyUpdater(engine, container));
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@tsparticles/updater-destroy",
+  "version": "3.0.0-alpha.0",
+  "description": "tsParticles particles destroy updater",
+  "homepage": "https://particles.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/matteobruni/tsparticles.git",
+    "directory": "updaters/destroy"
+  },
+  "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",
+    "@tsparticles/updater"
+  ],
+  "author": "Matteo Bruni <matteo.bruni@me.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/matteobruni/tsparticles/issues"
+  },
+  "main": "cjs/index.js",
+  "jsdelivr": "tsparticles.updater.destroy.min.js",
+  "unpkg": "tsparticles.updater.destroy.min.js",
+  "module": "esm/index.js",
+  "types": "types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@tsparticles/engine": "^3.0.0-alpha.0"
+  }
+}