@tsparticles/plugin-infection 3.0.0-alpha.0

package/tsparticles.plugin.infection.js

@@ -0,0 +1,387 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@tsparticles/engine"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@tsparticles/engine"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__533__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 533:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadInfectionPlugin": () => (/* binding */ loadInfectionPlugin)
+});
+
+// EXTERNAL MODULE: external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"}
+var engine_root_window_ = __webpack_require__(533);
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/InfectionStage.js
+
+class InfectionStage {
+  constructor() {
+    this.color = new engine_root_window_.OptionsColor();
+    this.color.value = "#ff0000";
+    this.radius = 0;
+    this.rate = 1;
+  }
+  load(data) {
+    if (data === undefined) {
+      return;
+    }
+    if (data.color !== undefined) {
+      this.color = engine_root_window_.OptionsColor.create(this.color, data.color);
+    }
+    this.duration = data.duration;
+    this.infectedStage = data.infectedStage;
+    if (data.radius !== undefined) {
+      this.radius = data.radius;
+    }
+    if (data.rate !== undefined) {
+      this.rate = data.rate;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/Infection.js
+
+class Infection {
+  constructor() {
+    this.cure = false;
+    this.delay = 0;
+    this.enable = false;
+    this.infections = 0;
+    this.stages = [];
+  }
+  load(data) {
+    if (data === undefined) {
+      return;
+    }
+    if (data.cure !== undefined) {
+      this.cure = data.cure;
+    }
+    if (data.delay !== undefined) {
+      this.delay = data.delay;
+    }
+    if (data.enable !== undefined) {
+      this.enable = data.enable;
+    }
+    if (data.infections !== undefined) {
+      this.infections = data.infections;
+    }
+    if (data.stages === undefined) {
+      return;
+    }
+    this.stages = data.stages.map(t => {
+      const s = new InfectionStage();
+      s.load(t);
+      return s;
+    });
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Infecter.js
+class Infecter {
+  constructor(container) {
+    this.container = container;
+  }
+  startInfection(particle, stage) {
+    const options = this.container.actualOptions;
+    if (!options.infection || !particle.infection) {
+      return;
+    }
+    const stages = options.infection.stages,
+      stagesCount = stages.length;
+    if (stage > stagesCount || stage < 0) {
+      return;
+    }
+    particle.infection.delay = 0;
+    particle.infection.delayStage = stage;
+  }
+  updateInfection(particle, delta) {
+    const infection = this.container.actualOptions.infection;
+    if (!infection || !particle.infection) {
+      return;
+    }
+    const stages = infection.stages,
+      stagesCount = stages.length;
+    if (particle.infection.delay !== undefined && particle.infection.delayStage !== undefined) {
+      const stage = particle.infection.delayStage;
+      if (stage > stagesCount || stage < 0) {
+        return;
+      }
+      if (particle.infection.delay >= infection.delay * 1000) {
+        particle.infection.stage = stage;
+        particle.infection.time = 0;
+        delete particle.infection.delay;
+        delete particle.infection.delayStage;
+      } else {
+        particle.infection.delay += delta;
+      }
+    } else {
+      delete particle.infection.delay;
+      delete particle.infection.delayStage;
+    }
+    if (particle.infection.stage !== undefined && particle.infection.time !== undefined) {
+      const infectionStage = stages[particle.infection.stage];
+      if (infectionStage.duration !== undefined && infectionStage.duration >= 0) {
+        if (particle.infection.time > infectionStage.duration * 1000) {
+          this.nextInfectionStage(particle);
+        } else {
+          particle.infection.time += delta;
+        }
+      } else {
+        particle.infection.time += delta;
+      }
+    } else {
+      delete particle.infection.stage;
+      delete particle.infection.time;
+    }
+  }
+  updateInfectionStage(particle, stage) {
+    const options = this.container.actualOptions;
+    if (!options.infection || !particle.infection) {
+      return;
+    }
+    const stagesCount = options.infection.stages.length;
+    if (stage > stagesCount || stage < 0 || particle.infection.stage !== undefined && particle.infection.stage > stage) {
+      return;
+    }
+    particle.infection.stage = stage;
+    particle.infection.time = 0;
+  }
+  nextInfectionStage(particle) {
+    const options = this.container.actualOptions;
+    if (!options.infection || !particle.infection) {
+      return;
+    }
+    const stagesCount = options.infection.stages.length;
+    if (stagesCount <= 0 || particle.infection.stage === undefined) {
+      return;
+    }
+    particle.infection.time = 0;
+    if (stagesCount <= ++particle.infection.stage) {
+      if (options.infection.cure) {
+        delete particle.infection.stage;
+        delete particle.infection.time;
+        return;
+      } else {
+        particle.infection.stage = 0;
+        particle.infection.time = 0;
+      }
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/InfectionInstance.js
+
+
+class InfectionInstance {
+  constructor(container) {
+    this.container = container;
+    this.container.infecter = new Infecter(this.container);
+  }
+  particleFillColor(particle) {
+    const options = this.container.actualOptions;
+    if (!particle.infection || !options.infection) {
+      return;
+    }
+    const infectionStage = particle.infection.stage,
+      infection = options.infection,
+      infectionStages = infection.stages;
+    return infectionStage !== undefined ? infectionStages[infectionStage].color : undefined;
+  }
+  particleStrokeColor(particle) {
+    return this.particleFillColor(particle);
+  }
+  particlesSetup() {
+    var _a;
+    const options = this.container.actualOptions;
+    if (!options.infection) {
+      return;
+    }
+    for (let i = 0; i < options.infection.infections; i++) {
+      const notInfected = this.container.particles.array.filter(p => {
+        const infP = p;
+        if (!infP.infection) {
+          infP.infection = {};
+        }
+        return infP.infection.stage === undefined;
+      });
+      const infected = (0,engine_root_window_.itemFromArray)(notInfected);
+      (_a = this.container.infecter) === null || _a === void 0 ? void 0 : _a.startInfection(infected, 0);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/ParticlesInfecter.js
+
+class ParticlesInfecter extends engine_root_window_.ParticlesInteractorBase {
+  constructor(container) {
+    super(container);
+  }
+  clear() {}
+  init() {}
+  async interact(p1, delta) {
+    var _a, _b, _c, _d, _e;
+    const infecter = this.container.infecter;
+    if (!infecter) {
+      return;
+    }
+    infecter.updateInfection(p1, delta.value);
+    if (((_a = p1.infection) === null || _a === void 0 ? void 0 : _a.stage) === undefined) {
+      return;
+    }
+    const container = this.container,
+      options = container.actualOptions,
+      infectionOptions = options.infection;
+    if (!(infectionOptions === null || infectionOptions === void 0 ? void 0 : infectionOptions.enable) || infectionOptions.stages.length < 1) {
+      return;
+    }
+    const infectionStage1 = infectionOptions.stages[p1.infection.stage],
+      pxRatio = container.retina.pixelRatio,
+      radius = p1.getRadius() * 2 + infectionStage1.radius * pxRatio,
+      pos = p1.getPosition(),
+      infectedStage1 = (_b = infectionStage1.infectedStage) !== null && _b !== void 0 ? _b : p1.infection.stage,
+      query = container.particles.quadTree.queryCircle(pos, radius),
+      infections = infectionStage1.rate,
+      neighbors = query.length;
+    for (const p2 of query) {
+      const infP2 = p2;
+      if (infP2 === p1 || infP2.destroyed || infP2.spawning || !(((_c = infP2.infection) === null || _c === void 0 ? void 0 : _c.stage) === undefined || infP2.infection.stage !== p1.infection.stage)) {
+        continue;
+      }
+      if ((0,engine_root_window_.getRandom)() < infections / neighbors) {
+        if (((_d = infP2.infection) === null || _d === void 0 ? void 0 : _d.stage) === undefined) {
+          infecter.startInfection(infP2, infectedStage1);
+        } else if (infP2.infection.stage < p1.infection.stage) {
+          infecter.updateInfectionStage(infP2, infectedStage1);
+        } else if (infP2.infection.stage > p1.infection.stage) {
+          const infectionStage2 = infectionOptions.stages[infP2.infection.stage];
+          const infectedStage2 = (_e = infectionStage2 === null || infectionStage2 === void 0 ? void 0 : infectionStage2.infectedStage) !== null && _e !== void 0 ? _e : infP2.infection.stage;
+          infecter.updateInfectionStage(p1, infectedStage2);
+        }
+      }
+    }
+  }
+  isEnabled() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.container.actualOptions) === null || _a === void 0 ? void 0 : _a.infection) === null || _b === void 0 ? void 0 : _b.enable) !== null && _c !== void 0 ? _c : false;
+  }
+  reset() {}
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+
+
+class InfectionPlugin {
+  constructor() {
+    this.id = "infection";
+  }
+  getPlugin(container) {
+    return new InfectionInstance(container);
+  }
+  loadOptions(options, source) {
+    if (!this.needsPlugin(source)) {
+      return;
+    }
+    let infectionOptions = options.infection;
+    if ((infectionOptions === null || infectionOptions === void 0 ? void 0 : infectionOptions.load) === undefined) {
+      options.infection = infectionOptions = new Infection();
+    }
+    infectionOptions.load(source === null || source === void 0 ? void 0 : source.infection);
+  }
+  needsPlugin(options) {
+    var _a, _b;
+    return (_b = (_a = options === null || options === void 0 ? void 0 : options.infection) === null || _a === void 0 ? void 0 : _a.enable) !== null && _b !== void 0 ? _b : false;
+  }
+}
+async function loadInfectionPlugin(engine) {
+  const plugin = new InfectionPlugin();
+  await engine.addPlugin(plugin);
+  await engine.addInteractor("particlesInfection", container => new ParticlesInfecter(container));
+}
+
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.plugin.infection.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.plugin.infection.min.js.LICENSE.txt */
+!function(e,t){if("object"==typeof exports&&"object"==typeof module)module.exports=t(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],t);else{var i="object"==typeof exports?t(require("@tsparticles/engine")):t(e.window);for(var n in i)("object"==typeof exports?exports:e)[n]=i[n]}}(this,(e=>(()=>{"use strict";var t={533:t=>{t.exports=e}},i={};function n(e){var o=i[e];if(void 0!==o)return o.exports;var c=i[e]={exports:{}};return t[e](c,c.exports,n),c.exports}n.d=(e,t)=>{for(var i in t)n.o(t,i)&&!n.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:t[i]})},n.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var o={};return(()=>{n.r(o),n.d(o,{loadInfectionPlugin:()=>l});var e=n(533);class t{constructor(){this.color=new e.OptionsColor,this.color.value="#ff0000",this.radius=0,this.rate=1}load(t){void 0!==t&&(void 0!==t.color&&(this.color=e.OptionsColor.create(this.color,t.color)),this.duration=t.duration,this.infectedStage=t.infectedStage,void 0!==t.radius&&(this.radius=t.radius),void 0!==t.rate&&(this.rate=t.rate))}}class i{constructor(){this.cure=!1,this.delay=0,this.enable=!1,this.infections=0,this.stages=[]}load(e){void 0!==e&&(void 0!==e.cure&&(this.cure=e.cure),void 0!==e.delay&&(this.delay=e.delay),void 0!==e.enable&&(this.enable=e.enable),void 0!==e.infections&&(this.infections=e.infections),void 0!==e.stages&&(this.stages=e.stages.map((e=>{const i=new t;return i.load(e),i}))))}}class c{constructor(e){this.container=e}startInfection(e,t){const i=this.container.actualOptions;if(!i.infection||!e.infection)return;t>i.infection.stages.length||t<0||(e.infection.delay=0,e.infection.delayStage=t)}updateInfection(e,t){const i=this.container.actualOptions.infection;if(!i||!e.infection)return;const n=i.stages,o=n.length;if(void 0!==e.infection.delay&&void 0!==e.infection.delayStage){const n=e.infection.delayStage;if(n>o||n<0)return;e.infection.delay>=1e3*i.delay?(e.infection.stage=n,e.infection.time=0,delete e.infection.delay,delete e.infection.delayStage):e.infection.delay+=t}else delete e.infection.delay,delete e.infection.delayStage;if(void 0!==e.infection.stage&&void 0!==e.infection.time){const i=n[e.infection.stage];void 0!==i.duration&&i.duration>=0&&e.infection.time>1e3*i.duration?this.nextInfectionStage(e):e.infection.time+=t}else delete e.infection.stage,delete e.infection.time}updateInfectionStage(e,t){const i=this.container.actualOptions;if(!i.infection||!e.infection)return;t>i.infection.stages.length||t<0||void 0!==e.infection.stage&&e.infection.stage>t||(e.infection.stage=t,e.infection.time=0)}nextInfectionStage(e){const t=this.container.actualOptions;if(!t.infection||!e.infection)return;const i=t.infection.stages.length;if(!(i<=0||void 0===e.infection.stage)&&(e.infection.time=0,i<=++e.infection.stage)){if(t.infection.cure)return delete e.infection.stage,void delete e.infection.time;e.infection.stage=0,e.infection.time=0}}}class a{constructor(e){this.container=e,this.container.infecter=new c(this.container)}particleFillColor(e){const t=this.container.actualOptions;if(!e.infection||!t.infection)return;const i=e.infection.stage,n=t.infection.stages;return void 0!==i?n[i].color:void 0}particleStrokeColor(e){return this.particleFillColor(e)}particlesSetup(){var t;const i=this.container.actualOptions;if(i.infection)for(let n=0;n<i.infection.infections;n++){const i=this.container.particles.array.filter((e=>{const t=e;return t.infection||(t.infection={}),void 0===t.infection.stage})),n=(0,e.itemFromArray)(i);null===(t=this.container.infecter)||void 0===t||t.startInfection(n,0)}}}class s extends e.ParticlesInteractorBase{constructor(e){super(e)}clear(){}init(){}async interact(t,i){var n,o,c,a,s;const r=this.container.infecter;if(!r)return;if(r.updateInfection(t,i.value),void 0===(null===(n=t.infection)||void 0===n?void 0:n.stage))return;const l=this.container,f=l.actualOptions.infection;if(!(null==f?void 0:f.enable)||f.stages.length<1)return;const d=f.stages[t.infection.stage],u=l.retina.pixelRatio,g=2*t.getRadius()+d.radius*u,v=t.getPosition(),p=null!==(o=d.infectedStage)&&void 0!==o?o:t.infection.stage,h=l.particles.quadTree.queryCircle(v,g),y=d.rate,S=h.length;for(const i of h){const n=i;if(!(n===t||n.destroyed||n.spawning||void 0!==(null===(c=n.infection)||void 0===c?void 0:c.stage)&&n.infection.stage===t.infection.stage)&&(0,e.getRandom)()<y/S)if(void 0===(null===(a=n.infection)||void 0===a?void 0:a.stage))r.startInfection(n,p);else if(n.infection.stage<t.infection.stage)r.updateInfectionStage(n,p);else if(n.infection.stage>t.infection.stage){const e=f.stages[n.infection.stage],i=null!==(s=null==e?void 0:e.infectedStage)&&void 0!==s?s:n.infection.stage;r.updateInfectionStage(t,i)}}}isEnabled(){var e,t,i;return null!==(i=null===(t=null===(e=this.container.actualOptions)||void 0===e?void 0:e.infection)||void 0===t?void 0:t.enable)&&void 0!==i&&i}reset(){}}class r{constructor(){this.id="infection"}getPlugin(e){return new a(e)}loadOptions(e,t){if(!this.needsPlugin(t))return;let n=e.infection;void 0===(null==n?void 0:n.load)&&(e.infection=n=new i),n.load(null==t?void 0:t.infection)}needsPlugin(e){var t,i;return null!==(i=null===(t=null==e?void 0:e.infection)||void 0===t?void 0:t.enable)&&void 0!==i&&i}}async function l(e){const t=new r;await e.addPlugin(t),await e.addInteractor("particlesInfection",(e=>new s(e)))}})(),o})()));

package/tsparticles.plugin.infection.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */

package/types/Infecter.d.ts

@@ -0,0 +1,9 @@
+import type { InfectableContainer, InfectableParticle } from "./Types";
+export declare class Infecter {
+    private readonly container;
+    constructor(container: InfectableContainer);
+    startInfection(particle: InfectableParticle, stage: number): void;
+    updateInfection(particle: InfectableParticle, delta: number): void;
+    updateInfectionStage(particle: InfectableParticle, stage: number): void;
+    private nextInfectionStage;
+}

package/types/InfectionInstance.d.ts

@@ -0,0 +1,9 @@
+import type { IContainerPlugin, IOptionsColor, Particle } from "@tsparticles/engine";
+import type { InfectableContainer, InfectableParticle } from "./Types";
+export declare class InfectionInstance implements IContainerPlugin {
+    private readonly container;
+    constructor(container: InfectableContainer);
+    particleFillColor(particle: InfectableParticle): string | IOptionsColor | undefined;
+    particleStrokeColor(particle: Particle): string | IOptionsColor | undefined;
+    particlesSetup(): void;
+}

package/types/Options/Classes/Infection.d.ts

@@ -0,0 +1,12 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { IInfection } from "../Interfaces/IInfection";
+import { InfectionStage } from "./InfectionStage";
+export declare class Infection implements IInfection, IOptionLoader<IInfection> {
+    cure: boolean;
+    delay: number;
+    enable: boolean;
+    infections: number;
+    stages: InfectionStage[];
+    constructor();
+    load(data?: RecursivePartial<IInfection>): void;
+}

package/types/Options/Classes/InfectionStage.d.ts

@@ -0,0 +1,12 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { IInfectionStage } from "../Interfaces/IInfectionStage";
+import { OptionsColor } from "@tsparticles/engine";
+export declare class InfectionStage implements IInfectionStage, IOptionLoader<IInfectionStage> {
+    color: OptionsColor;
+    duration?: number;
+    infectedStage?: number;
+    radius: number;
+    rate: number;
+    constructor();
+    load(data?: RecursivePartial<IInfectionStage>): void;
+}

package/types/Options/Interfaces/IInfection.d.ts

@@ -0,0 +1,8 @@
+import type { IInfectionStage } from "./IInfectionStage";
+export interface IInfection {
+    cure: boolean;
+    delay: number;
+    enable: boolean;
+    infections: number;
+    stages: IInfectionStage[];
+}

package/types/Options/Interfaces/IInfectionStage.d.ts

@@ -0,0 +1,8 @@
+import type { IOptionsColor } from "@tsparticles/engine";
+export interface IInfectionStage {
+    color: string | IOptionsColor;
+    duration?: number;
+    infectedStage?: number;
+    radius: number;
+    rate: number;
+}

package/types/ParticlesInfecter.d.ts

@@ -0,0 +1,11 @@
+import type { InfectableContainer, InfectableParticle } from "./Types";
+import { ParticlesInteractorBase } from "@tsparticles/engine";
+import type { IDelta } from "@tsparticles/engine";
+export declare class ParticlesInfecter extends ParticlesInteractorBase<InfectableContainer> {
+    constructor(container: InfectableContainer);
+    clear(): void;
+    init(): void;
+    interact(p1: InfectableParticle, delta: IDelta): Promise<void>;
+    isEnabled(): boolean;
+    reset(): void;
+}

package/types/Types.d.ts

@@ -0,0 +1,24 @@
+import type { Container, IOptions, IParticle, Options, Particle } from "@tsparticles/engine";
+import type { IInfection } from "./Options/Interfaces/IInfection";
+import type { Infecter } from "./Infecter";
+import type { Infection } from "./Options/Classes/Infection";
+export interface IParticleInfection {
+    delay?: number;
+    delayStage?: number;
+    stage?: number;
+    time?: number;
+}
+export type InfectableContainer = Container & {
+    actualOptions: InfectionOptions;
+    infecter?: Infecter;
+};
+export type IInfectableParticle = IParticle & {
+    infection?: IParticleInfection;
+};
+export type IInfectionOptions = IOptions & {
+    infection: IInfection;
+};
+export type InfectionOptions = Options & {
+    infection?: Infection;
+};
+export type InfectableParticle = Particle & IInfectableParticle;

package/types/index.d.ts

@@ -0,0 +1,4 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadInfectionPlugin(engine: Engine): Promise<void>;
+export * from "./Options/Interfaces/IInfection";
+export * from "./Options/Interfaces/IInfectionStage";

package/umd/Infecter.js

@@ -0,0 +1,111 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Infecter = void 0;
+    class Infecter {
+        constructor(container) {
+            this.container = container;
+        }
+        startInfection(particle, stage) {
+            const options = this.container.actualOptions;
+            if (!options.infection || !particle.infection) {
+                return;
+            }
+            const stages = options.infection.stages, stagesCount = stages.length;
+            if (stage > stagesCount || stage < 0) {
+                return;
+            }
+            particle.infection.delay = 0;
+            particle.infection.delayStage = stage;
+        }
+        updateInfection(particle, delta) {
+            const infection = this.container.actualOptions.infection;
+            if (!infection || !particle.infection) {
+                return;
+            }
+            const stages = infection.stages, stagesCount = stages.length;
+            if (particle.infection.delay !== undefined && particle.infection.delayStage !== undefined) {
+                const stage = particle.infection.delayStage;
+                if (stage > stagesCount || stage < 0) {
+                    return;
+                }
+                if (particle.infection.delay >= infection.delay * 1000) {
+                    particle.infection.stage = stage;
+                    particle.infection.time = 0;
+                    delete particle.infection.delay;
+                    delete particle.infection.delayStage;
+                }
+                else {
+                    particle.infection.delay += delta;
+                }
+            }
+            else {
+                delete particle.infection.delay;
+                delete particle.infection.delayStage;
+            }
+            if (particle.infection.stage !== undefined && particle.infection.time !== undefined) {
+                const infectionStage = stages[particle.infection.stage];
+                if (infectionStage.duration !== undefined && infectionStage.duration >= 0) {
+                    if (particle.infection.time > infectionStage.duration * 1000) {
+                        this.nextInfectionStage(particle);
+                    }
+                    else {
+                        particle.infection.time += delta;
+                    }
+                }
+                else {
+                    particle.infection.time += delta;
+                }
+            }
+            else {
+                delete particle.infection.stage;
+                delete particle.infection.time;
+            }
+        }
+        updateInfectionStage(particle, stage) {
+            const options = this.container.actualOptions;
+            if (!options.infection || !particle.infection) {
+                return;
+            }
+            const stagesCount = options.infection.stages.length;
+            if (stage > stagesCount ||
+                stage < 0 ||
+                (particle.infection.stage !== undefined && particle.infection.stage > stage)) {
+                return;
+            }
+            particle.infection.stage = stage;
+            particle.infection.time = 0;
+        }
+        nextInfectionStage(particle) {
+            const options = this.container.actualOptions;
+            if (!options.infection || !particle.infection) {
+                return;
+            }
+            const stagesCount = options.infection.stages.length;
+            if (stagesCount <= 0 || particle.infection.stage === undefined) {
+                return;
+            }
+            particle.infection.time = 0;
+            if (stagesCount <= ++particle.infection.stage) {
+                if (options.infection.cure) {
+                    delete particle.infection.stage;
+                    delete particle.infection.time;
+                    return;
+                }
+                else {
+                    particle.infection.stage = 0;
+                    particle.infection.time = 0;
+                }
+            }
+        }
+    }
+    exports.Infecter = Infecter;
+});