@tsparticles/updater-rotate 3.0.0-beta.0

package/tsparticles.updater.rotate.js

@@ -0,0 +1,257 @@
+/*!
+ * 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-beta.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__, {
+  loadRotateUpdater: () => (/* binding */ loadRotateUpdater)
+});
+
+// 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/RotateAnimation.js
+
+class RotateAnimation {
+  constructor() {
+    this.enable = false;
+    this.speed = 0;
+    this.decay = 0;
+    this.sync = false;
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    if (data.enable !== undefined) {
+      this.enable = data.enable;
+    }
+    if (data.speed !== undefined) {
+      this.speed = (0,engine_root_window_.setRangeValue)(data.speed);
+    }
+    if (data.decay !== undefined) {
+      this.decay = (0,engine_root_window_.setRangeValue)(data.decay);
+    }
+    if (data.sync !== undefined) {
+      this.sync = data.sync;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/Options/Classes/Rotate.js
+
+
+class Rotate extends engine_root_window_.ValueWithRandom {
+  constructor() {
+    super();
+    this.animation = new RotateAnimation();
+    this.direction = "clockwise";
+    this.path = false;
+    this.value = 0;
+  }
+  load(data) {
+    if (!data) {
+      return;
+    }
+    super.load(data);
+    if (data.direction !== undefined) {
+      this.direction = data.direction;
+    }
+    this.animation.load(data.animation);
+    if (data.path !== undefined) {
+      this.path = data.path;
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/RotateUpdater.js
+
+
+function updateRotate(particle, delta) {
+  const rotate = particle.rotate,
+    rotateOptions = particle.options.rotate;
+  if (!rotate || !rotateOptions) {
+    return;
+  }
+  const rotateAnimation = rotateOptions.animation,
+    speed = (rotate.velocity ?? 0) * delta.factor,
+    max = 2 * Math.PI,
+    decay = rotate.decay ?? 1;
+  if (!rotateAnimation.enable) {
+    return;
+  }
+  switch (rotate.status) {
+    case "increasing":
+      rotate.value += speed;
+      if (rotate.value > max) {
+        rotate.value -= max;
+      }
+      break;
+    case "decreasing":
+    default:
+      rotate.value -= speed;
+      if (rotate.value < 0) {
+        rotate.value += max;
+      }
+      break;
+  }
+  if (rotate.velocity && decay !== 1) {
+    rotate.velocity *= decay;
+  }
+}
+class RotateUpdater {
+  constructor(container) {
+    this.container = container;
+  }
+  init(particle) {
+    const rotateOptions = particle.options.rotate;
+    if (!rotateOptions) {
+      return;
+    }
+    particle.rotate = {
+      enable: rotateOptions.animation.enable,
+      value: (0,engine_root_window_.getRangeValue)(rotateOptions.value) * Math.PI / 180
+    };
+    particle.pathRotation = rotateOptions.path;
+    let rotateDirection = rotateOptions.direction;
+    if (rotateDirection === "random") {
+      const index = Math.floor((0,engine_root_window_.getRandom)() * 2);
+      rotateDirection = index > 0 ? "counter-clockwise" : "clockwise";
+    }
+    switch (rotateDirection) {
+      case "counter-clockwise":
+      case "counterClockwise":
+        particle.rotate.status = "decreasing";
+        break;
+      case "clockwise":
+        particle.rotate.status = "increasing";
+        break;
+    }
+    const rotateAnimation = rotateOptions.animation;
+    if (rotateAnimation.enable) {
+      particle.rotate.decay = 1 - (0,engine_root_window_.getRangeValue)(rotateAnimation.decay);
+      particle.rotate.velocity = (0,engine_root_window_.getRangeValue)(rotateAnimation.speed) / 360 * this.container.retina.reduceFactor;
+      if (!rotateAnimation.sync) {
+        particle.rotate.velocity *= (0,engine_root_window_.getRandom)();
+      }
+    }
+    particle.rotation = particle.rotate.value;
+  }
+  isEnabled(particle) {
+    const rotate = particle.options.rotate;
+    if (!rotate) {
+      return false;
+    }
+    return !particle.destroyed && !particle.spawning && rotate.animation.enable && !rotate.path;
+  }
+  loadOptions(options, ...sources) {
+    if (!options.rotate) {
+      options.rotate = new Rotate();
+    }
+    for (const source of sources) {
+      options.rotate.load(source?.rotate);
+    }
+  }
+  update(particle, delta) {
+    if (!this.isEnabled(particle)) {
+      return;
+    }
+    updateRotate(particle, delta);
+    particle.rotation = particle.rotate?.value ?? 0;
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+async function loadRotateUpdater(engine, refresh = true) {
+  await engine.addParticleUpdater("rotate", container => new RotateUpdater(container), refresh);
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.updater.rotate.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.updater.rotate.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 a="object"==typeof exports?t(require("@tsparticles/engine")):t(e.window);for(var o in a)("object"==typeof exports?exports:e)[o]=a[o]}}(this,(e=>(()=>{"use strict";var t={533:t=>{t.exports=e}},a={};function o(e){var n=a[e];if(void 0!==n)return n.exports;var i=a[e]={exports:{}};return t[e](i,i.exports,o),i.exports}o.d=(e,t)=>{for(var a in t)o.o(t,a)&&!o.o(e,a)&&Object.defineProperty(e,a,{enumerable:!0,get:t[a]})},o.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),o.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var n={};return(()=>{o.r(n),o.d(n,{loadRotateUpdater:()=>r});var e=o(533);class t{constructor(){this.enable=!1,this.speed=0,this.decay=0,this.sync=!1}load(t){t&&(void 0!==t.enable&&(this.enable=t.enable),void 0!==t.speed&&(this.speed=(0,e.setRangeValue)(t.speed)),void 0!==t.decay&&(this.decay=(0,e.setRangeValue)(t.decay)),void 0!==t.sync&&(this.sync=t.sync))}}class a extends e.ValueWithRandom{constructor(){super(),this.animation=new t,this.direction="clockwise",this.path=!1,this.value=0}load(e){e&&(super.load(e),void 0!==e.direction&&(this.direction=e.direction),this.animation.load(e.animation),void 0!==e.path&&(this.path=e.path))}}class i{constructor(e){this.container=e}init(t){const a=t.options.rotate;if(!a)return;t.rotate={enable:a.animation.enable,value:(0,e.getRangeValue)(a.value)*Math.PI/180},t.pathRotation=a.path;let o=a.direction;if("random"===o){o=Math.floor(2*(0,e.getRandom)())>0?"counter-clockwise":"clockwise"}switch(o){case"counter-clockwise":case"counterClockwise":t.rotate.status="decreasing";break;case"clockwise":t.rotate.status="increasing"}const n=a.animation;n.enable&&(t.rotate.decay=1-(0,e.getRangeValue)(n.decay),t.rotate.velocity=(0,e.getRangeValue)(n.speed)/360*this.container.retina.reduceFactor,n.sync||(t.rotate.velocity*=(0,e.getRandom)())),t.rotation=t.rotate.value}isEnabled(e){const t=e.options.rotate;return!!t&&(!e.destroyed&&!e.spawning&&t.animation.enable&&!t.path)}loadOptions(e,...t){e.rotate||(e.rotate=new a);for(const a of t)e.rotate.load(a?.rotate)}update(e,t){this.isEnabled(e)&&(!function(e,t){const a=e.rotate,o=e.options.rotate;if(!a||!o)return;const n=o.animation,i=(a.velocity??0)*t.factor,r=2*Math.PI,s=a.decay??1;n.enable&&("increasing"===a.status?(a.value+=i,a.value>r&&(a.value-=r)):(a.value-=i,a.value<0&&(a.value+=r)),a.velocity&&1!==s&&(a.velocity*=s))}(e,t),e.rotation=e.rotate?.value??0)}}async function r(e,t=!0){await e.addParticleUpdater("rotate",(e=>new i(e)),t)}})(),n})()));

package/tsparticles.updater.rotate.min.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! tsParticles Rotate Updater v3.0.0-beta.0 by Matteo Bruni */

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

@@ -0,0 +1,10 @@
+import { type IOptionLoader, type RecursivePartial, RotateDirection, type RotateDirectionAlt, ValueWithRandom } from "@tsparticles/engine";
+import type { IRotate } from "../Interfaces/IRotate";
+import { RotateAnimation } from "./RotateAnimation";
+export declare class Rotate extends ValueWithRandom implements IRotate, IOptionLoader<IRotate> {
+    animation: RotateAnimation;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    path: boolean;
+    constructor();
+    load(data?: RecursivePartial<IRotate>): void;
+}

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

@@ -0,0 +1,10 @@
+import { type IOptionLoader, type RangeValue, type RecursivePartial } from "@tsparticles/engine";
+import type { IRotateAnimation } from "../Interfaces/IRotateAnimation";
+export declare class RotateAnimation implements IRotateAnimation, IOptionLoader<IRotateAnimation> {
+    decay: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+    constructor();
+    load(data?: RecursivePartial<IRotateAnimation>): void;
+}

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

@@ -0,0 +1,7 @@
+import type { IValueWithRandom, RotateDirection, RotateDirectionAlt } from "@tsparticles/engine";
+import type { IRotateAnimation } from "./IRotateAnimation";
+export interface IRotate extends IValueWithRandom {
+    animation: IRotateAnimation;
+    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
+    path: boolean;
+}

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

@@ -0,0 +1,7 @@
+import type { RangeValue } from "@tsparticles/engine";
+export interface IRotateAnimation {
+    decay: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+    sync: boolean;
+}

package/types/RotateUpdater.d.ts

@@ -0,0 +1,22 @@
+import { type Container, type IDelta, type IParticleUpdater, type IParticleValueAnimation, type IParticlesOptions, type Particle, type ParticlesOptions, type RecursivePartial } from "@tsparticles/engine";
+import type { IRotate } from "./Options/Interfaces/IRotate";
+import { Rotate } from "./Options/Classes/Rotate";
+type RotateParticle = Particle & {
+    options: RotateParticlesOptions;
+    rotate?: IParticleValueAnimation<number>;
+};
+type IRotateParticlesOptions = IParticlesOptions & {
+    rotate?: IRotate;
+};
+type RotateParticlesOptions = ParticlesOptions & {
+    rotate?: Rotate;
+};
+export declare class RotateUpdater implements IParticleUpdater {
+    private readonly container;
+    constructor(container: Container);
+    init(particle: RotateParticle): void;
+    isEnabled(particle: RotateParticle): boolean;
+    loadOptions(options: RotateParticlesOptions, ...sources: (RecursivePartial<IRotateParticlesOptions> | undefined)[]): void;
+    update(particle: RotateParticle, delta: IDelta): void;
+}
+export {};

package/types/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadRotateUpdater(engine: Engine, refresh?: boolean): Promise<void>;

package/umd/Options/Classes/Rotate.js

@@ -0,0 +1,38 @@
+(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", "./RotateAnimation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Rotate = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const RotateAnimation_1 = require("./RotateAnimation");
+    class Rotate extends engine_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new RotateAnimation_1.RotateAnimation();
+            this.direction = "clockwise";
+            this.path = false;
+            this.value = 0;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            super.load(data);
+            if (data.direction !== undefined) {
+                this.direction = data.direction;
+            }
+            this.animation.load(data.animation);
+            if (data.path !== undefined) {
+                this.path = data.path;
+            }
+        }
+    }
+    exports.Rotate = Rotate;
+});

package/umd/Options/Classes/RotateAnimation.js

@@ -0,0 +1,40 @@
+(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.RotateAnimation = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class RotateAnimation {
+        constructor() {
+            this.enable = false;
+            this.speed = 0;
+            this.decay = 0;
+            this.sync = false;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.speed !== undefined) {
+                this.speed = (0, engine_1.setRangeValue)(data.speed);
+            }
+            if (data.decay !== undefined) {
+                this.decay = (0, engine_1.setRangeValue)(data.decay);
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.RotateAnimation = RotateAnimation;
+});

package/umd/Options/Interfaces/IRotate.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/Options/Interfaces/IRotateAnimation.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/RotateUpdater.js

@@ -0,0 +1,106 @@
+(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/Rotate"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RotateUpdater = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Rotate_1 = require("./Options/Classes/Rotate");
+    function updateRotate(particle, delta) {
+        const rotate = particle.rotate, rotateOptions = particle.options.rotate;
+        if (!rotate || !rotateOptions) {
+            return;
+        }
+        const rotateAnimation = rotateOptions.animation, speed = (rotate.velocity ?? 0) * delta.factor, max = 2 * Math.PI, decay = rotate.decay ?? 1;
+        if (!rotateAnimation.enable) {
+            return;
+        }
+        switch (rotate.status) {
+            case "increasing":
+                rotate.value += speed;
+                if (rotate.value > max) {
+                    rotate.value -= max;
+                }
+                break;
+            case "decreasing":
+            default:
+                rotate.value -= speed;
+                if (rotate.value < 0) {
+                    rotate.value += max;
+                }
+                break;
+        }
+        if (rotate.velocity && decay !== 1) {
+            rotate.velocity *= decay;
+        }
+    }
+    class RotateUpdater {
+        constructor(container) {
+            this.container = container;
+        }
+        init(particle) {
+            const rotateOptions = particle.options.rotate;
+            if (!rotateOptions) {
+                return;
+            }
+            particle.rotate = {
+                enable: rotateOptions.animation.enable,
+                value: ((0, engine_1.getRangeValue)(rotateOptions.value) * Math.PI) / 180,
+            };
+            particle.pathRotation = rotateOptions.path;
+            let rotateDirection = rotateOptions.direction;
+            if (rotateDirection === "random") {
+                const index = Math.floor((0, engine_1.getRandom)() * 2);
+                rotateDirection = index > 0 ? "counter-clockwise" : "clockwise";
+            }
+            switch (rotateDirection) {
+                case "counter-clockwise":
+                case "counterClockwise":
+                    particle.rotate.status = "decreasing";
+                    break;
+                case "clockwise":
+                    particle.rotate.status = "increasing";
+                    break;
+            }
+            const rotateAnimation = rotateOptions.animation;
+            if (rotateAnimation.enable) {
+                particle.rotate.decay = 1 - (0, engine_1.getRangeValue)(rotateAnimation.decay);
+                particle.rotate.velocity =
+                    ((0, engine_1.getRangeValue)(rotateAnimation.speed) / 360) * this.container.retina.reduceFactor;
+                if (!rotateAnimation.sync) {
+                    particle.rotate.velocity *= (0, engine_1.getRandom)();
+                }
+            }
+            particle.rotation = particle.rotate.value;
+        }
+        isEnabled(particle) {
+            const rotate = particle.options.rotate;
+            if (!rotate) {
+                return false;
+            }
+            return !particle.destroyed && !particle.spawning && rotate.animation.enable && !rotate.path;
+        }
+        loadOptions(options, ...sources) {
+            if (!options.rotate) {
+                options.rotate = new Rotate_1.Rotate();
+            }
+            for (const source of sources) {
+                options.rotate.load(source?.rotate);
+            }
+        }
+        update(particle, delta) {
+            if (!this.isEnabled(particle)) {
+                return;
+            }
+            updateRotate(particle, delta);
+            particle.rotation = particle.rotate?.value ?? 0;
+        }
+    }
+    exports.RotateUpdater = RotateUpdater;
+});

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", "./RotateUpdater"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadRotateUpdater = void 0;
+    const RotateUpdater_1 = require("./RotateUpdater");
+    async function loadRotateUpdater(engine, refresh = true) {
+        await engine.addParticleUpdater("rotate", (container) => new RotateUpdater_1.RotateUpdater(container), refresh);
+    }
+    exports.loadRotateUpdater = loadRotateUpdater;
+});