@tsparticles/plugin-poisson-disc 4.0.0-alpha.8 → 4.0.0-beta.0

package/umd/PoissonDisc.js

@@ -12,6 +12,17 @@
     exports.PoissonDisc = void 0;
     const engine_1 = require("@tsparticles/engine");
     class PoissonDisc {
+        active;
+        cellSize;
+        cols;
+        dimensions;
+        firstPoint;
+        grid;
+        points;
+        radius;
+        retries;
+        rows;
+        size;
         constructor(size, radius, retries, dimensions, firstPoint) {
             this.size = { ...size };
             this.radius = radius;
@@ -74,18 +85,22 @@
         }
         async run() {
             this.reset();
-            const minCount = 0, step = 1;
+            const minCount = 0, step = 1, yieldEvery = 100, yieldStepModule = 0;
+            let iterations = 0;
             while (this.active.length > minCount) {
-                await this.steps(step);
+                this.steps(step);
+                if (++iterations % yieldEvery === yieldStepModule) {
+                    await new Promise(resolve => setTimeout(resolve));
+                }
             }
         }
-        async steps(steps) {
+        steps(steps) {
             const minCount = 0;
             for (let i = 0; i < steps; i++) {
                 if (this.active.length <= minCount) {
                     continue;
                 }
-                await this._step();
+                this._step();
             }
         }
         _getNewPoint(currentPoint, tries) {
@@ -99,79 +114,76 @@
                 x: Math.floor(newPoint.x / this.cellSize),
                 y: Math.floor(newPoint.y / this.cellSize),
             };
-            if (newPoint.x > minCoordinate &&
-                newPoint.x < this.size.width &&
-                newPoint.y > minCoordinate &&
-                newPoint.y < this.size.height) {
-                const row = this.grid[newGridCoords.y];
-                if (!row) {
-                    return;
-                }
-                const point = row[newGridCoords.x];
-                if (point === undefined) {
-                    return;
-                }
-                if (point < gridMinValue) {
-                    for (let i = -1; i <= maxNeighbourIndex; i++) {
-                        for (let j = -1; j <= maxNeighbourIndex; j++) {
-                            const neighbourGrid = {
-                                x: newGridCoords.x + j,
-                                y: newGridCoords.y + i,
-                            };
-                            if (neighbourGrid.x >= minCoordinate &&
-                                neighbourGrid.y >= minCoordinate &&
-                                neighbourGrid.x < this.cols &&
-                                neighbourGrid.y < this.rows &&
-                                (neighbourGrid.x !== newGridCoords.x || neighbourGrid.y !== newGridCoords.y)) {
-                                if (point >= gridMinValue) {
-                                    const neighbourIndex = point, neighbour = this.points[neighbourIndex];
-                                    if (!neighbour) {
-                                        continue;
-                                    }
-                                    const dist = (0, engine_1.getDistance)(newPoint, neighbour.position);
-                                    if (dist < this.radius) {
-                                        return;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                else {
-                    return;
-                }
+            if (newPoint.x <= minCoordinate ||
+                newPoint.x >= this.size.width ||
+                newPoint.y <= minCoordinate ||
+                newPoint.y >= this.size.height) {
+                return;
             }
-            else {
+            const row = this.grid[newGridCoords.y];
+            if (!row) {
                 return;
             }
-            return newPoint;
-        }
-        async _step() {
-            const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
-            return new Promise(resolve => {
-                let foundNewPoint = false;
-                for (let tries = 0; tries < this.retries; tries++) {
-                    const randomActivePointIndex = this.active[randomActive];
-                    if (randomActivePointIndex === undefined) {
+            const cellValue = row[newGridCoords.x];
+            if (cellValue === undefined) {
+                return;
+            }
+            if (cellValue >= gridMinValue) {
+                return;
+            }
+            for (let i = -1; i <= maxNeighbourIndex; i++) {
+                for (let j = -1; j <= maxNeighbourIndex; j++) {
+                    if (!i && !j) {
+                        continue;
+                    }
+                    const neighbourGrid = {
+                        x: newGridCoords.x + j,
+                        y: newGridCoords.y + i,
+                    };
+                    if (neighbourGrid.x < minCoordinate ||
+                        neighbourGrid.y < minCoordinate ||
+                        neighbourGrid.x >= this.cols ||
+                        neighbourGrid.y >= this.rows) {
+                        continue;
+                    }
+                    const neighbourCellValue = this.grid[neighbourGrid.y]?.[neighbourGrid.x];
+                    if (neighbourCellValue === undefined || neighbourCellValue < gridMinValue) {
                         continue;
                     }
-                    const point = this.points[randomActivePointIndex];
-                    if (!point) {
+                    const neighbour = this.points[neighbourCellValue];
+                    if (!neighbour) {
                         continue;
                     }
-                    const newPoint = this._getNewPoint(point, tries);
-                    if (newPoint) {
-                        foundNewPoint = true;
-                        this.addPoint(newPoint);
-                        break;
+                    if ((0, engine_1.getDistance)(newPoint, neighbour.position) < this.radius) {
+                        return;
                     }
                 }
-                if (!foundNewPoint) {
-                    const deleteCount = 1;
-                    this.active.splice(randomActive, deleteCount);
+            }
+            return newPoint;
+        }
+        _step() {
+            const minCount = 0, randomActive = this.getRandom(minCount, this.active.length);
+            let foundNewPoint = false;
+            for (let tries = 0; tries < this.retries; tries++) {
+                const randomActivePointIndex = this.active[randomActive];
+                if (randomActivePointIndex === undefined) {
+                    continue;
+                }
+                const point = this.points[randomActivePointIndex];
+                if (!point) {
+                    continue;
                 }
-                resolve();
-            });
+                const newPoint = this._getNewPoint(point, tries);
+                if (newPoint) {
+                    foundNewPoint = true;
+                    this.addPoint(newPoint);
+                    break;
+                }
+            }
+            if (!foundNewPoint) {
+                const deleteCount = 1;
+                this.active.splice(randomActive, deleteCount);
+            }
         }
     }
     exports.PoissonDisc = PoissonDisc;

package/umd/PoissonDiscPlugin.js

@@ -46,9 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     exports.PoissonDiscPlugin = void 0;
     const Poisson_js_1 = require("./Options/Classes/Poisson.js");
     class PoissonDiscPlugin {
-        constructor() {
-            this.id = "poisson";
-        }
+        id = "poisson";
         async getPlugin(container) {
             const { PoissonDiscPluginInstance } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./PoissonDiscPluginInstance.js"))) : new Promise((resolve_1, reject_1) => { require(["./PoissonDiscPluginInstance.js"], resolve_1, reject_1); }).then(__importStar));
             return new PoissonDiscPluginInstance(container);

package/umd/PoissonDiscPluginInstance.js

@@ -1,18 +1,55 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 (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", "./PoissonDisc.js"], factory);
+        define(["require", "exports", "@tsparticles/engine"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var __syncRequire = typeof module === "object" && typeof module.exports === "object";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.PoissonDiscPluginInstance = void 0;
     const engine_1 = require("@tsparticles/engine");
-    const PoissonDisc_js_1 = require("./PoissonDisc.js");
     class PoissonDiscPluginInstance {
+        poissonDisc;
+        redrawTimeout;
+        _container;
+        _currentIndex;
         constructor(container) {
             this._container = container;
             this._currentIndex = 0;
@@ -38,6 +75,9 @@
             const timeout = 250;
             this.redrawTimeout = setTimeout(() => {
                 void (async () => {
+                    if (this._container.destroyed) {
+                        return;
+                    }
                     await this._initData();
                     await container.particles.redraw();
                 })();
@@ -52,12 +92,13 @@
                 return;
             }
             this._currentIndex = 0;
-            this.poissonDisc = new PoissonDisc_js_1.PoissonDisc(canvasSize, poissonOptions.radius
+            const { PoissonDisc } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./PoissonDisc.js"))) : new Promise((resolve_1, reject_1) => { require(["./PoissonDisc.js"], resolve_1, reject_1); }).then(__importStar));
+            this.poissonDisc = new PoissonDisc(canvasSize, poissonOptions.radius
                 ? poissonOptions.radius * pixelRatio
                 : Math.max((0, engine_1.getRangeMax)(particlesOptions.size.value) * pixelRatio, Math.sqrt((canvasSize.width * canvasSize.height) / particlesOptions.number.value)), poissonOptions.retries, poissonOptions.dimensions);
             const noSteps = 0;
             if (poissonOptions.steps > noSteps) {
-                await this.poissonDisc.steps(poissonOptions.steps);
+                this.poissonDisc.steps(poissonOptions.steps);
             }
             else {
                 await this.poissonDisc.run();

package/umd/index.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || (function () {
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.loadPoissonDiscPlugin = loadPoissonDiscPlugin;
     async function loadPoissonDiscPlugin(engine) {
-        engine.checkVersion("4.0.0-alpha.8");
+        engine.checkVersion("4.0.0-beta.0");
         await engine.register(async (e) => {
             const { PoissonDiscPlugin } = await (__syncRequire ? Promise.resolve().then(() => __importStar(require("./PoissonDiscPlugin.js"))) : new Promise((resolve_1, reject_1) => { require(["./PoissonDiscPlugin.js"], resolve_1, reject_1); }).then(__importStar));
             e.addPlugin(new PoissonDiscPlugin());

package/336.min.js

@@ -1,2 +0,0 @@
-/*! For license information please see 336.min.js.LICENSE.txt */
-(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[336],{336(i,t,s){s.d(t,{PoissonDiscPluginInstance:()=>n});var e=s(303);class o{constructor(i,t,s,e,o){this.size={...i},this.radius=t,this.retries=s,this.dimensions=e,this.cellSize=Math.floor(this.radius/Math.sqrt(this.dimensions)),this.cols=Math.floor(this.size.width/this.cellSize),this.rows=Math.floor(this.size.height/this.cellSize),this.points=[],this.active=[],this.grid=[],this.firstPoint=o?{...o}:void 0,this.reset()}addPoint(i){const t={position:{...i},gridPosition:{x:Math.floor(i.x/this.cellSize),y:Math.floor(i.y/this.cellSize)}},s=this.points.length,e=this.grid[t.gridPosition.y];e&&(this.points.push(t),e[t.gridPosition.x]=s,this.active.push(s))}getRandom(i,t){return Math.floor((0,e.getRandom)()*(t-i))+i}initialiseGrid(){for(let i=0;i<=this.rows;i++){this.grid[i]=[];const t=this.grid[i];if(t)for(let i=0;i<=this.cols;i++)t[i]=-1}}reset(){if(this.points=[],this.active=[],this.grid=[],this.initialiseGrid(),this.firstPoint)this.addPoint(this.firstPoint);else{const i=0;this.addPoint({x:this.getRandom(i,this.size.width),y:this.getRandom(i,this.size.height)})}}async run(){this.reset();for(;this.active.length>0;)await this.steps(1)}async steps(i){for(let t=0;t<i;t++)this.active.length<=0||await this._step()}_getNewPoint(i,t){const s=t*(e.doublePI/this.retries),o=this.getRandom(this.radius,this.radius*e.double),n=Math.cos(s)*o,h=Math.sin(s)*o,r={x:Math.floor(i.position.x+n),y:Math.floor(i.position.y+h)},a=Math.floor(r.x/this.cellSize),c=Math.floor(r.y/this.cellSize);if(r.x>0&&r.x<this.size.width&&r.y>0&&r.y<this.size.height){{const i=this.grid[c];if(!i)return;const t=i[a];if(void 0===t)return;if(!(t<0))return;for(let i=-1;i<=1;i++)for(let s=-1;s<=1;s++){const o={x:a+s,y:c+i};if(o.x>=0&&o.y>=0&&o.x<this.cols&&o.y<this.rows&&(o.x!==a||o.y!==c)&&t>=0){const i=t,s=this.points[i];if(!s)continue;if((0,e.getDistance)(r,s.position)<this.radius)return}}}return r}}async _step(){const i=this.getRandom(0,this.active.length);return new Promise((t=>{let s=!1;for(let t=0;t<this.retries;t++){const e=this.active[i];if(void 0===e)continue;const o=this.points[e];if(!o)continue;const n=this._getNewPoint(o,t);if(n){s=!0,this.addPoint(n);break}}if(!s){const t=1;this.active.splice(i,t)}t()}))}}class n{constructor(i){this._container=i,this._currentIndex=0}async init(){await this._initData()}particlePosition(i){const t=this._container.actualOptions.poisson;if(this.poissonDisc&&t?.enable&&!(this._currentIndex>=this.poissonDisc.points.length))return i??this.poissonDisc.points[this._currentIndex++]?.position}resize(){const i=this._container,t=i.actualOptions.poisson;if(!t?.enable)return;this.redrawTimeout&&clearTimeout(this.redrawTimeout);this.redrawTimeout=setTimeout((()=>{(async()=>{await this._initData(),await i.particles.redraw()})()}),250)}stop(){delete this.poissonDisc}async _initData(){const i=this._container,t=i.actualOptions.poisson,s=i.actualOptions.particles,n=i.canvas.size,h=i.retina.pixelRatio;if(!t?.enable)return;this._currentIndex=0,this.poissonDisc=new o(n,t.radius?t.radius*h:Math.max((0,e.getRangeMax)(s.size.value)*h,Math.sqrt(n.width*n.height/s.number.value)),t.retries,t.dimensions);t.steps>0?await this.poissonDisc.steps(t.steps):await this.poissonDisc.run()}}}}]);

package/336.min.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! tsParticles Poisson Disc Plugin v4.0.0-alpha.8 by Matteo Bruni */

package/879.min.js

@@ -1,2 +0,0 @@
-/*! For license information please see 879.min.js.LICENSE.txt */
-(this.webpackChunk_tsparticles_plugin_poisson_disc=this.webpackChunk_tsparticles_plugin_poisson_disc||[]).push([[879],{879(s,i,n){n.d(i,{PoissonDiscPlugin:()=>t});var e=n(303);class o{constructor(){this.enable=!1,this.dimensions=2,this.radius=0,this.retries=30,this.steps=0}load(s){(0,e.isNull)(s)||(void 0!==s.enable&&(this.enable=s.enable),void 0!==s.dimensions&&(this.dimensions=s.dimensions),void 0!==s.radius&&(this.radius=s.radius),void 0!==s.retries&&(this.retries=s.retries))}}class t{constructor(){this.id="poisson"}async getPlugin(s){const{PoissonDiscPluginInstance:i}=await n.e(336).then(n.bind(n,336));return new i(s)}loadOptions(s,i,n){if(!this.needsPlugin(i)&&!this.needsPlugin(n))return;let e=i.poisson;void 0===e?.load&&(i.poisson=e=new o),e.load(n?.poisson)}needsPlugin(s){return s?.poisson?.enable??!1}}}}]);

package/879.min.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! tsParticles Poisson Disc Plugin v4.0.0-alpha.8 by Matteo Bruni */

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

@@ -1 +0,0 @@
-/*! tsParticles Poisson Disc Plugin v4.0.0-alpha.8 by Matteo Bruni */