@tsparticles/updater-orbit 3.0.0-alpha.0

package/tsparticles.updater.orbit.js

@@ -0,0 +1,252 @@
+/*!
+ * 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__, {
+  "loadOrbitUpdater": () => (/* binding */ loadOrbitUpdater)
+});
+
+// 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/OrbitRotation.js
+
+class OrbitRotation extends engine_root_window_.ValueWithRandom {
+  constructor() {
+    super();
+    this.value = 45;
+    this.random.enable = false;
+    this.random.minimumValue = 0;
+  }
+  load(data) {
+    if (data === undefined) {
+      return;
+    }
+    super.load(data);
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/Orbit.js
+
+
+class Orbit {
+  constructor() {
+    this.animation = new engine_root_window_.AnimationOptions();
+    this.enable = false;
+    this.opacity = 1;
+    this.rotation = new OrbitRotation();
+    this.width = 1;
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    this.animation.load(data.animation);
+    this.rotation.load(data.rotation);
+    if (data.enable !== undefined) {
+      this.enable = data.enable;
+    }
+    if (data.opacity !== undefined) {
+      this.opacity = (0,engine_root_window_.setRangeValue)(data.opacity);
+    }
+    if (data.width !== undefined) {
+      this.width = (0,engine_root_window_.setRangeValue)(data.width);
+    }
+    if (data.radius !== undefined) {
+      this.radius = (0,engine_root_window_.setRangeValue)(data.radius);
+    }
+    if (data.color !== undefined) {
+      this.color = engine_root_window_.OptionsColor.create(this.color, data.color);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/OrbitUpdater.js
+
+
+function drawEllipse(context, particle, fillColorValue, radius, opacity, width, rotation, start, end) {
+  if (width <= 0) {
+    return;
+  }
+  const pos = particle.getPosition();
+  if (fillColorValue) {
+    context.strokeStyle = (0,engine_root_window_.getStyleFromHsl)(fillColorValue, opacity);
+  }
+  context.lineWidth = width;
+  const rotationRadian = rotation * Math.PI / 180;
+  context.beginPath();
+  context.ellipse(pos.x, pos.y, radius / 2, radius * 2, rotationRadian, start, end);
+  context.stroke();
+}
+class OrbitUpdater {
+  constructor(container) {
+    this.container = container;
+  }
+  afterDraw(particle) {
+    const orbitOptions = particle.options.orbit;
+    if (orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable) {
+      this.drawOrbit(particle, "front");
+    }
+  }
+  beforeDraw(particle) {
+    const orbitOptions = particle.options.orbit;
+    if (orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable) {
+      this.drawOrbit(particle, "back");
+    }
+  }
+  drawOrbit(particle, type) {
+    const container = this.container;
+    let start, end;
+    switch (type) {
+      case "back":
+        start = Math.PI / 2;
+        end = Math.PI * 3 / 2;
+        break;
+      case "front":
+        start = Math.PI * 3 / 2;
+        end = Math.PI / 2;
+        break;
+      default:
+        start = 0;
+        end = 2 * Math.PI;
+    }
+    container.canvas.draw(ctx => {
+      var _a, _b, _c, _d, _e, _f;
+      drawEllipse(ctx, particle, (_a = particle.orbitColor) !== null && _a !== void 0 ? _a : particle.getFillColor(), (_c = (_b = particle.retina.orbitRadius) !== null && _b !== void 0 ? _b : container.retina.orbitRadius) !== null && _c !== void 0 ? _c : particle.getRadius(), (_d = particle.orbitOpacity) !== null && _d !== void 0 ? _d : 1, (_e = particle.orbitWidth) !== null && _e !== void 0 ? _e : 1, ((_f = particle.orbitRotation) !== null && _f !== void 0 ? _f : 0) * container.retina.pixelRatio, start, end);
+    });
+  }
+  init(particle) {
+    const container = this.container,
+      particlesOptions = particle.options,
+      orbitOptions = particlesOptions.orbit;
+    if (!(orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable)) {
+      return;
+    }
+    particle.orbitRotation = (0,engine_root_window_.getRangeValue)(orbitOptions.rotation.value);
+    particle.orbitColor = (0,engine_root_window_.rangeColorToHsl)(orbitOptions.color);
+    particle.retina.orbitRadius = orbitOptions.radius !== undefined ? (0,engine_root_window_.getRangeValue)(orbitOptions.radius) * container.retina.pixelRatio : undefined;
+    container.retina.orbitRadius = particle.retina.orbitRadius;
+    particle.orbitAnimationSpeed = orbitOptions.animation.enable ? (0,engine_root_window_.getRangeValue)(orbitOptions.animation.speed) : 0;
+    particle.orbitWidth = (0,engine_root_window_.getRangeValue)(orbitOptions.width);
+    particle.orbitOpacity = (0,engine_root_window_.getRangeValue)(orbitOptions.opacity);
+  }
+  isEnabled(particle) {
+    var _a;
+    const orbitAnimations = (_a = particle.options.orbit) === null || _a === void 0 ? void 0 : _a.animation;
+    return !particle.destroyed && !particle.spawning && !!(orbitAnimations === null || orbitAnimations === void 0 ? void 0 : orbitAnimations.enable);
+  }
+  loadOptions(options, ...sources) {
+    if (!options.orbit) {
+      options.orbit = new Orbit();
+    }
+    for (const source of sources) {
+      options.orbit.load(source === null || source === void 0 ? void 0 : source.orbit);
+    }
+  }
+  update(particle, delta) {
+    var _a;
+    if (!this.isEnabled(particle)) {
+      return;
+    }
+    if (particle.orbitRotation === undefined) {
+      particle.orbitRotation = 0;
+    }
+    particle.orbitRotation += ((_a = particle.orbitAnimationSpeed) !== null && _a !== void 0 ? _a : 0 / (Math.PI * 2)) * delta.factor;
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+function loadOrbitUpdater(engine) {
+  engine.addParticleUpdater("orbit", container => new OrbitUpdater(container));
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.updater.orbit.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.updater.orbit.min.js.LICENSE.txt */
+!function(t,o){if("object"==typeof exports&&"object"==typeof module)module.exports=o(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],o);else{var i="object"==typeof exports?o(require("@tsparticles/engine")):o(t.window);for(var e in i)("object"==typeof exports?exports:t)[e]=i[e]}}(this,(t=>(()=>{"use strict";var o={533:o=>{o.exports=t}},i={};function e(t){var a=i[t];if(void 0!==a)return a.exports;var r=i[t]={exports:{}};return o[t](r,r.exports,e),r.exports}e.d=(t,o)=>{for(var i in o)e.o(o,i)&&!e.o(t,i)&&Object.defineProperty(t,i,{enumerable:!0,get:o[i]})},e.o=(t,o)=>Object.prototype.hasOwnProperty.call(t,o),e.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})};var a={};return(()=>{e.r(a),e.d(a,{loadOrbitUpdater:()=>n});var t=e(533);class o extends t.ValueWithRandom{constructor(){super(),this.value=45,this.random.enable=!1,this.random.minimumValue=0}load(t){void 0!==t&&super.load(t)}}class i{constructor(){this.animation=new t.AnimationOptions,this.enable=!1,this.opacity=1,this.rotation=new o,this.width=1}load(o){o&&(this.animation.load(o.animation),this.rotation.load(o.rotation),void 0!==o.enable&&(this.enable=o.enable),void 0!==o.opacity&&(this.opacity=(0,t.setRangeValue)(o.opacity)),void 0!==o.width&&(this.width=(0,t.setRangeValue)(o.width)),void 0!==o.radius&&(this.radius=(0,t.setRangeValue)(o.radius)),void 0!==o.color&&(this.color=t.OptionsColor.create(this.color,o.color)))}}class r{constructor(t){this.container=t}afterDraw(t){const o=t.options.orbit;(null==o?void 0:o.enable)&&this.drawOrbit(t,"front")}beforeDraw(t){const o=t.options.orbit;(null==o?void 0:o.enable)&&this.drawOrbit(t,"back")}drawOrbit(o,i){const e=this.container;let a,r;switch(i){case"back":a=Math.PI/2,r=3*Math.PI/2;break;case"front":a=3*Math.PI/2,r=Math.PI/2;break;default:a=0,r=2*Math.PI}e.canvas.draw((i=>{var n,l,s,d,u,b;!function(o,i,e,a,r,n,l,s,d){if(n<=0)return;const u=i.getPosition();e&&(o.strokeStyle=(0,t.getStyleFromHsl)(e,r)),o.lineWidth=n;const b=l*Math.PI/180;o.beginPath(),o.ellipse(u.x,u.y,a/2,2*a,b,s,d),o.stroke()}(i,o,null!==(n=o.orbitColor)&&void 0!==n?n:o.getFillColor(),null!==(s=null!==(l=o.retina.orbitRadius)&&void 0!==l?l:e.retina.orbitRadius)&&void 0!==s?s:o.getRadius(),null!==(d=o.orbitOpacity)&&void 0!==d?d:1,null!==(u=o.orbitWidth)&&void 0!==u?u:1,(null!==(b=o.orbitRotation)&&void 0!==b?b:0)*e.retina.pixelRatio,a,r)}))}init(o){const i=this.container,e=o.options.orbit;(null==e?void 0:e.enable)&&(o.orbitRotation=(0,t.getRangeValue)(e.rotation.value),o.orbitColor=(0,t.rangeColorToHsl)(e.color),o.retina.orbitRadius=void 0!==e.radius?(0,t.getRangeValue)(e.radius)*i.retina.pixelRatio:void 0,i.retina.orbitRadius=o.retina.orbitRadius,o.orbitAnimationSpeed=e.animation.enable?(0,t.getRangeValue)(e.animation.speed):0,o.orbitWidth=(0,t.getRangeValue)(e.width),o.orbitOpacity=(0,t.getRangeValue)(e.opacity))}isEnabled(t){var o;const i=null===(o=t.options.orbit)||void 0===o?void 0:o.animation;return!t.destroyed&&!t.spawning&&!!(null==i?void 0:i.enable)}loadOptions(t,...o){t.orbit||(t.orbit=new i);for(const i of o)t.orbit.load(null==i?void 0:i.orbit)}update(t,o){var i;this.isEnabled(t)&&(void 0===t.orbitRotation&&(t.orbitRotation=0),t.orbitRotation+=(null!==(i=t.orbitAnimationSpeed)&&void 0!==i?i:0/(2*Math.PI))*o.factor)}}function n(t){t.addParticleUpdater("orbit",(t=>new r(t)))}})(),a})()));

package/tsparticles.updater.orbit.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/Options/Classes/Orbit.d.ts

@@ -0,0 +1,15 @@
+import { AnimationOptions, OptionsColor } from "@tsparticles/engine";
+import type { IAnimatable, IOptionLoader, RangeValue, RecursivePartial } from "@tsparticles/engine";
+import type { IOrbit } from "../Interfaces/IOrbit";
+import { OrbitRotation } from "./OrbitRotation";
+export declare class Orbit implements IOrbit, IOptionLoader<IOrbit>, IAnimatable<AnimationOptions> {
+    animation: AnimationOptions;
+    color?: OptionsColor;
+    enable: boolean;
+    opacity: RangeValue;
+    radius?: RangeValue;
+    rotation: OrbitRotation;
+    width: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IOrbit>): void;
+}

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

@@ -0,0 +1,6 @@
+import type { IValueWithRandom, RecursivePartial } from "@tsparticles/engine";
+import { ValueWithRandom } from "@tsparticles/engine";
+export declare class OrbitRotation extends ValueWithRandom {
+    constructor();
+    load(data?: RecursivePartial<IValueWithRandom>): void;
+}

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

@@ -0,0 +1,9 @@
+import type { IAnimatable, IAnimation, IOptionsColor, IValueWithRandom, RangeValue } from "@tsparticles/engine";
+export interface IOrbit extends IAnimatable<IAnimation> {
+    color?: string | IOptionsColor;
+    enable: boolean;
+    opacity: RangeValue;
+    radius?: RangeValue;
+    rotation: IValueWithRandom;
+    width: RangeValue;
+}

package/types/OrbitUpdater.d.ts

@@ -0,0 +1,42 @@
+import type { Container, IDelta, IHsl, IParticleRetinaProps, IParticleUpdater, IParticlesOptions, Particle, ParticlesOptions, RecursivePartial, Retina } from "@tsparticles/engine";
+import type { IOrbit } from "./Options/Interfaces/IOrbit";
+import { Orbit } from "./Options/Classes/Orbit";
+export declare const enum OrbitType {
+    front = "front",
+    back = "back"
+}
+type IOrbitParticlesOptions = IParticlesOptions & {
+    orbit?: IOrbit;
+};
+type OrbitParticlesOptions = ParticlesOptions & {
+    orbit?: Orbit;
+};
+type OrbitRetina = Retina & {
+    orbitRadius?: number;
+};
+type OrbitContainer = Container & {
+    retina: OrbitRetina;
+};
+type OrbitParticle = Particle & {
+    options: OrbitParticlesOptions;
+    orbitAnimationSpeed?: number;
+    orbitColor?: IHsl;
+    orbitOpacity?: number;
+    orbitRotation?: number;
+    orbitWidth?: number;
+    retina: IParticleRetinaProps & {
+        orbitRadius?: number;
+    };
+};
+export declare class OrbitUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: OrbitContainer);
+    afterDraw(particle: OrbitParticle): void;
+    beforeDraw(particle: OrbitParticle): void;
+    drawOrbit(particle: OrbitParticle, type: OrbitType): void;
+    init(particle: OrbitParticle): void;
+    isEnabled(particle: OrbitParticle): boolean;
+    loadOptions(options: OrbitParticlesOptions, ...sources: (RecursivePartial<IOrbitParticlesOptions> | undefined)[]): void;
+    update(particle: OrbitParticle, delta: IDelta): void;
+}
+export {};

package/types/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadOrbitUpdater(engine: Engine): void;

package/umd/Options/Classes/Orbit.js

@@ -0,0 +1,47 @@
+(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", "@tsparticles/engine", "./OrbitRotation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Orbit = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const OrbitRotation_1 = require("./OrbitRotation");
+    class Orbit {
+        constructor() {
+            this.animation = new engine_1.AnimationOptions();
+            this.enable = false;
+            this.opacity = 1;
+            this.rotation = new OrbitRotation_1.OrbitRotation();
+            this.width = 1;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            this.animation.load(data.animation);
+            this.rotation.load(data.rotation);
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = (0, engine_1.setRangeValue)(data.opacity);
+            }
+            if (data.width !== undefined) {
+                this.width = (0, engine_1.setRangeValue)(data.width);
+            }
+            if (data.radius !== undefined) {
+                this.radius = (0, engine_1.setRangeValue)(data.radius);
+            }
+            if (data.color !== undefined) {
+                this.color = engine_1.OptionsColor.create(this.color, data.color);
+            }
+        }
+    }
+    exports.Orbit = Orbit;
+});

package/umd/Options/Classes/OrbitRotation.js

@@ -0,0 +1,29 @@
+(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", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OrbitRotation = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class OrbitRotation extends engine_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.value = 45;
+            this.random.enable = false;
+            this.random.minimumValue = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            super.load(data);
+        }
+    }
+    exports.OrbitRotation = OrbitRotation;
+});

package/umd/Options/Interfaces/IOrbit.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/OrbitUpdater.js

@@ -0,0 +1,107 @@
+(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", "@tsparticles/engine", "./Options/Classes/Orbit"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OrbitUpdater = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Orbit_1 = require("./Options/Classes/Orbit");
+    function drawEllipse(context, particle, fillColorValue, radius, opacity, width, rotation, start, end) {
+        if (width <= 0) {
+            return;
+        }
+        const pos = particle.getPosition();
+        if (fillColorValue) {
+            context.strokeStyle = (0, engine_1.getStyleFromHsl)(fillColorValue, opacity);
+        }
+        context.lineWidth = width;
+        const rotationRadian = (rotation * Math.PI) / 180;
+        context.beginPath();
+        context.ellipse(pos.x, pos.y, radius / 2, radius * 2, rotationRadian, start, end);
+        context.stroke();
+    }
+    class OrbitUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        afterDraw(particle) {
+            const orbitOptions = particle.options.orbit;
+            if (orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable) {
+                this.drawOrbit(particle, "front");
+            }
+        }
+        beforeDraw(particle) {
+            const orbitOptions = particle.options.orbit;
+            if (orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable) {
+                this.drawOrbit(particle, "back");
+            }
+        }
+        drawOrbit(particle, type) {
+            const container = this.container;
+            let start, end;
+            switch (type) {
+                case "back":
+                    start = Math.PI / 2;
+                    end = (Math.PI * 3) / 2;
+                    break;
+                case "front":
+                    start = (Math.PI * 3) / 2;
+                    end = Math.PI / 2;
+                    break;
+                default:
+                    start = 0;
+                    end = 2 * Math.PI;
+            }
+            container.canvas.draw((ctx) => {
+                var _a, _b, _c, _d, _e, _f;
+                drawEllipse(ctx, particle, (_a = particle.orbitColor) !== null && _a !== void 0 ? _a : particle.getFillColor(), (_c = (_b = particle.retina.orbitRadius) !== null && _b !== void 0 ? _b : container.retina.orbitRadius) !== null && _c !== void 0 ? _c : particle.getRadius(), (_d = particle.orbitOpacity) !== null && _d !== void 0 ? _d : 1, (_e = particle.orbitWidth) !== null && _e !== void 0 ? _e : 1, ((_f = particle.orbitRotation) !== null && _f !== void 0 ? _f : 0) * container.retina.pixelRatio, start, end);
+            });
+        }
+        init(particle) {
+            const container = this.container, particlesOptions = particle.options, orbitOptions = particlesOptions.orbit;
+            if (!(orbitOptions === null || orbitOptions === void 0 ? void 0 : orbitOptions.enable)) {
+                return;
+            }
+            particle.orbitRotation = (0, engine_1.getRangeValue)(orbitOptions.rotation.value);
+            particle.orbitColor = (0, engine_1.rangeColorToHsl)(orbitOptions.color);
+            particle.retina.orbitRadius =
+                orbitOptions.radius !== undefined
+                    ? (0, engine_1.getRangeValue)(orbitOptions.radius) * container.retina.pixelRatio
+                    : undefined;
+            container.retina.orbitRadius = particle.retina.orbitRadius;
+            particle.orbitAnimationSpeed = orbitOptions.animation.enable ? (0, engine_1.getRangeValue)(orbitOptions.animation.speed) : 0;
+            particle.orbitWidth = (0, engine_1.getRangeValue)(orbitOptions.width);
+            particle.orbitOpacity = (0, engine_1.getRangeValue)(orbitOptions.opacity);
+        }
+        isEnabled(particle) {
+            var _a;
+            const orbitAnimations = (_a = particle.options.orbit) === null || _a === void 0 ? void 0 : _a.animation;
+            return !particle.destroyed && !particle.spawning && !!(orbitAnimations === null || orbitAnimations === void 0 ? void 0 : orbitAnimations.enable);
+        }
+        loadOptions(options, ...sources) {
+            if (!options.orbit) {
+                options.orbit = new Orbit_1.Orbit();
+            }
+            for (const source of sources) {
+                options.orbit.load(source === null || source === void 0 ? void 0 : source.orbit);
+            }
+        }
+        update(particle, delta) {
+            var _a;
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            if (particle.orbitRotation === undefined) {
+                particle.orbitRotation = 0;
+            }
+            particle.orbitRotation += ((_a = particle.orbitAnimationSpeed) !== null && _a !== void 0 ? _a : 0 / (Math.PI * 2)) * delta.factor;
+        }
+    }
+    exports.OrbitUpdater = OrbitUpdater;
+});

package/umd/index.js

@@ -0,0 +1,18 @@
+(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", "./OrbitUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadOrbitUpdater = void 0;
+    const OrbitUpdater_1 = require("./OrbitUpdater");
+    function loadOrbitUpdater(engine) {
+        engine.addParticleUpdater("orbit", (container) => new OrbitUpdater_1.OrbitUpdater(container));
+    }
+    exports.loadOrbitUpdater = loadOrbitUpdater;
+});