tsparticles 1.42.2 → 1.43.0

package/Core/Particles.js

@@ -1,322 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Particles_engine;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Particles = void 0;
-const Utils_1 = require("./Utils");
-const Utils_2 = require("../Utils");
-const Particle_1 = require("./Particle");
-const ParticlesOptions_1 = require("../Options/Classes/Particles/ParticlesOptions");
-class Particles {
-    constructor(engine, container) {
-        this.container = container;
-        _Particles_engine.set(this, void 0);
-        __classPrivateFieldSet(this, _Particles_engine, engine, "f");
-        this.nextId = 0;
-        this.array = [];
-        this.zArray = [];
-        this.mover = new Utils_1.ParticlesMover(container);
-        this.limit = 0;
-        this.needsSort = false;
-        this.lastZIndex = 0;
-        this.freqs = {
-            links: new Map(),
-            triangles: new Map(),
-        };
-        this.interactionManager = new Utils_1.InteractionManager(__classPrivateFieldGet(this, _Particles_engine, "f"), container);
-        const canvasSize = this.container.canvas.size;
-        this.linksColors = new Map();
-        this.quadTree = new Utils_1.QuadTree(new Utils_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
-        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
-    }
-    get count() {
-        return this.array.length;
-    }
-    init() {
-        var _a;
-        const container = this.container;
-        const options = container.actualOptions;
-        this.lastZIndex = 0;
-        this.needsSort = false;
-        this.freqs.links = new Map();
-        this.freqs.triangles = new Map();
-        let handled = false;
-        this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
-        this.interactionManager.init();
-        for (const [, plugin] of container.plugins) {
-            if (plugin.particlesInitialization !== undefined) {
-                handled = plugin.particlesInitialization();
-            }
-            if (handled) {
-                break;
-            }
-        }
-        this.addManualParticles();
-        if (!handled) {
-            for (const group in options.particles.groups) {
-                const groupOptions = options.particles.groups[group];
-                for (let i = this.count, j = 0; j < ((_a = groupOptions.number) === null || _a === void 0 ? void 0 : _a.value) && i < options.particles.number.value; i++, j++) {
-                    this.addParticle(undefined, groupOptions, group);
-                }
-            }
-            for (let i = this.count; i < options.particles.number.value; i++) {
-                this.addParticle();
-            }
-        }
-        container.pathGenerator.init(container);
-    }
-    async redraw() {
-        this.clear();
-        this.init();
-        await this.draw({ value: 0, factor: 0 });
-    }
-    removeAt(index, quantity = 1, group, override) {
-        if (!(index >= 0 && index <= this.count)) {
-            return;
-        }
-        let deleted = 0;
-        for (let i = index; deleted < quantity && i < this.count; i++) {
-            const particle = this.array[i];
-            if (!particle || particle.group !== group) {
-                continue;
-            }
-            particle.destroy(override);
-            this.array.splice(i--, 1);
-            const zIdx = this.zArray.indexOf(particle);
-            this.zArray.splice(zIdx, 1);
-            deleted++;
-        }
-    }
-    remove(particle, group, override) {
-        this.removeAt(this.array.indexOf(particle), undefined, group, override);
-    }
-    async update(delta) {
-        const container = this.container;
-        const particlesToDelete = [];
-        container.pathGenerator.update();
-        for (const [, plugin] of container.plugins) {
-            if (plugin.update !== undefined) {
-                plugin.update(delta);
-            }
-        }
-        for (const particle of this.array) {
-            const resizeFactor = container.canvas.resizeFactor;
-            if (resizeFactor && !particle.ignoresResizeRatio) {
-                particle.position.x *= resizeFactor.width;
-                particle.position.y *= resizeFactor.height;
-            }
-            particle.ignoresResizeRatio = false;
-            particle.bubble.inRange = false;
-            for (const [, plugin] of this.container.plugins) {
-                if (particle.destroyed) {
-                    break;
-                }
-                if (plugin.particleUpdate) {
-                    plugin.particleUpdate(particle, delta);
-                }
-            }
-            this.mover.move(particle, delta);
-            if (particle.destroyed) {
-                particlesToDelete.push(particle);
-                continue;
-            }
-            this.quadTree.insert(new Utils_1.Point(particle.getPosition(), particle));
-        }
-        for (const particle of particlesToDelete) {
-            this.remove(particle);
-        }
-        await this.interactionManager.externalInteract(delta);
-        for (const particle of container.particles.array) {
-            for (const updater of this.updaters) {
-                updater.update(particle, delta);
-            }
-            if (!particle.destroyed && !particle.spawning) {
-                await this.interactionManager.particlesInteract(particle, delta);
-            }
-        }
-        delete container.canvas.resizeFactor;
-    }
-    async draw(delta) {
-        const container = this.container;
-        container.canvas.clear();
-        const canvasSize = this.container.canvas.size;
-        this.quadTree = new Utils_1.QuadTree(new Utils_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
-        await this.update(delta);
-        if (this.needsSort) {
-            this.zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
-            this.lastZIndex = this.zArray[this.zArray.length - 1].position.z;
-            this.needsSort = false;
-        }
-        for (const [, plugin] of container.plugins) {
-            container.canvas.drawPlugin(plugin, delta);
-        }
-        for (const p of this.zArray) {
-            p.draw(delta);
-        }
-    }
-    clear() {
-        this.array = [];
-        this.zArray = [];
-    }
-    push(nb, mouse, overrideOptions, group) {
-        this.pushing = true;
-        for (let i = 0; i < nb; i++) {
-            this.addParticle(mouse === null || mouse === void 0 ? void 0 : mouse.position, overrideOptions, group);
-        }
-        this.pushing = false;
-    }
-    addParticle(position, overrideOptions, group) {
-        const container = this.container, options = container.actualOptions, limit = options.particles.number.limit * container.density;
-        if (limit > 0) {
-            const countToRemove = this.count + 1 - limit;
-            if (countToRemove > 0) {
-                this.removeQuantity(countToRemove);
-            }
-        }
-        return this.pushParticle(position, overrideOptions, group);
-    }
-    addSplitParticle(parent) {
-        const splitOptions = parent.options.destroy.split, options = new ParticlesOptions_1.ParticlesOptions();
-        options.load(parent.options);
-        const factor = (0, Utils_2.getRangeValue)(splitOptions.factor.value);
-        options.color.load({
-            value: {
-                hsl: parent.getFillColor(),
-            },
-        });
-        if (typeof options.size.value === "number") {
-            options.size.value /= factor;
-        }
-        else {
-            options.size.value.min /= factor;
-            options.size.value.max /= factor;
-        }
-        options.load(splitOptions.particles);
-        const offset = splitOptions.sizeOffset ? (0, Utils_2.setRangeValue)(-parent.size.value, parent.size.value) : 0;
-        const position = {
-            x: parent.position.x + (0, Utils_2.randomInRange)(offset),
-            y: parent.position.y + (0, Utils_2.randomInRange)(offset),
-        };
-        return this.pushParticle(position, options, parent.group, (particle) => {
-            if (particle.size.value < 0.5) {
-                return false;
-            }
-            particle.velocity.length = (0, Utils_2.randomInRange)((0, Utils_2.setRangeValue)(parent.velocity.length, particle.velocity.length));
-            particle.splitCount = parent.splitCount + 1;
-            particle.unbreakable = true;
-            setTimeout(() => {
-                particle.unbreakable = false;
-            }, 500);
-            return true;
-        });
-    }
-    removeQuantity(quantity, group) {
-        this.removeAt(0, quantity, group);
-    }
-    getLinkFrequency(p1, p2) {
-        const range = (0, Utils_2.setRangeValue)(p1.id, p2.id), key = `${(0, Utils_2.getRangeMin)(range)}_${(0, Utils_2.getRangeMax)(range)}`;
-        let res = this.freqs.links.get(key);
-        if (res === undefined) {
-            res = Math.random();
-            this.freqs.links.set(key, res);
-        }
-        return res;
-    }
-    getTriangleFrequency(p1, p2, p3) {
-        let [id1, id2, id3] = [p1.id, p2.id, p3.id];
-        if (id1 > id2) {
-            [id2, id1] = [id1, id2];
-        }
-        if (id2 > id3) {
-            [id3, id2] = [id2, id3];
-        }
-        if (id1 > id3) {
-            [id3, id1] = [id1, id3];
-        }
-        const key = `${id1}_${id2}_${id3}`;
-        let res = this.freqs.triangles.get(key);
-        if (res === undefined) {
-            res = Math.random();
-            this.freqs.triangles.set(key, res);
-        }
-        return res;
-    }
-    addManualParticles() {
-        const container = this.container, options = container.actualOptions;
-        for (const particle of options.manualParticles) {
-            const pos = particle.position
-                ? {
-                    x: (particle.position.x * container.canvas.size.width) / 100,
-                    y: (particle.position.y * container.canvas.size.height) / 100,
-                }
-                : undefined;
-            this.addParticle(pos, particle.options);
-        }
-    }
-    setDensity() {
-        const options = this.container.actualOptions;
-        for (const group in options.particles.groups) {
-            this.applyDensity(options.particles.groups[group], 0, group);
-        }
-        this.applyDensity(options.particles, options.manualParticles.length);
-    }
-    applyDensity(options, manualCount, group) {
-        var _a;
-        if (!((_a = options.number.density) === null || _a === void 0 ? void 0 : _a.enable)) {
-            return;
-        }
-        const numberOptions = options.number;
-        const densityFactor = this.initDensityFactor(numberOptions.density);
-        const optParticlesNumber = numberOptions.value;
-        const optParticlesLimit = numberOptions.limit > 0 ? numberOptions.limit : optParticlesNumber;
-        const particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount;
-        const particlesCount = Math.min(this.count, this.array.filter((t) => t.group === group).length);
-        this.limit = numberOptions.limit * densityFactor;
-        if (particlesCount < particlesNumber) {
-            this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
-        }
-        else if (particlesCount > particlesNumber) {
-            this.removeQuantity(particlesCount - particlesNumber, group);
-        }
-    }
-    initDensityFactor(densityOptions) {
-        const container = this.container;
-        if (!container.canvas.element || !densityOptions.enable) {
-            return 1;
-        }
-        const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
-        return (canvas.width * canvas.height) / (densityOptions.factor * pxRatio ** 2 * densityOptions.area);
-    }
-    pushParticle(position, overrideOptions, group, initializer) {
-        try {
-            const particle = new Particle_1.Particle(__classPrivateFieldGet(this, _Particles_engine, "f"), this.nextId, this.container, position, overrideOptions, group);
-            let canAdd = true;
-            if (initializer) {
-                canAdd = initializer(particle);
-            }
-            if (!canAdd) {
-                return;
-            }
-            this.array.push(particle);
-            this.zArray.push(particle);
-            this.nextId++;
-            return particle;
-        }
-        catch (e) {
-            console.warn(`error adding particle: ${e}`);
-            return;
-        }
-    }
-}
-exports.Particles = Particles;
-_Particles_engine = new WeakMap();

package/Core/Retina.d.ts

@@ -1,26 +0,0 @@
-import type { Container } from "./Container";
-import type { Particle } from "./Particle";
-export declare class Retina {
-    private readonly container;
-    reduceFactor: number;
-    bubbleModeDistance: number;
-    bubbleModeSize?: number;
-    connectModeDistance: number;
-    connectModeRadius: number;
-    grabModeDistance: number;
-    repulseModeDistance: number;
-    attractModeDistance: number;
-    attractDistance: number;
-    slowModeRadius: number;
-    linksDistance: number;
-    linksWidth: number;
-    sizeAnimationSpeed: number;
-    pixelRatio: number;
-    bounceModeDistance: number;
-    maxSpeed: number;
-    orbitRadius?: number;
-    constructor(container: Container);
-    init(): void;
-    initParticle(particle: Particle): void;
-    private handleMotionChange;
-}

package/Core/Retina.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Retina = void 0;
-const Utils_1 = require("../Utils");
-class Retina {
-    constructor(container) {
-        this.container = container;
-    }
-    init() {
-        const container = this.container;
-        const options = container.actualOptions;
-        this.pixelRatio = !options.detectRetina || (0, Utils_1.isSsr)() ? 1 : window.devicePixelRatio;
-        const motionOptions = this.container.actualOptions.motion;
-        if (motionOptions && (motionOptions.disable || motionOptions.reduce.value)) {
-            if ((0, Utils_1.isSsr)() || typeof matchMedia === "undefined" || !matchMedia) {
-                this.reduceFactor = 1;
-            }
-            else {
-                const mediaQuery = matchMedia("(prefers-reduced-motion: reduce)");
-                if (mediaQuery) {
-                    this.handleMotionChange(mediaQuery);
-                    const handleChange = () => {
-                        this.handleMotionChange(mediaQuery);
-                        container.refresh().catch(() => {
-                        });
-                    };
-                    if (mediaQuery.addEventListener !== undefined) {
-                        mediaQuery.addEventListener("change", handleChange);
-                    }
-                    else if (mediaQuery.addListener !== undefined) {
-                        mediaQuery.addListener(handleChange);
-                    }
-                }
-            }
-        }
-        else {
-            this.reduceFactor = 1;
-        }
-        const ratio = this.pixelRatio;
-        if (container.canvas.element) {
-            const element = container.canvas.element;
-            container.canvas.size.width = element.offsetWidth * ratio;
-            container.canvas.size.height = element.offsetHeight * ratio;
-        }
-        const particles = options.particles;
-        this.attractDistance = (0, Utils_1.getRangeValue)(particles.move.attract.distance) * ratio;
-        this.linksDistance = particles.links.distance * ratio;
-        this.linksWidth = particles.links.width * ratio;
-        this.sizeAnimationSpeed = (0, Utils_1.getRangeValue)(particles.size.animation.speed) * ratio;
-        this.maxSpeed = (0, Utils_1.getRangeValue)(particles.move.gravity.maxSpeed) * ratio;
-        if (particles.orbit.radius !== undefined) {
-            this.orbitRadius = (0, Utils_1.getRangeValue)(particles.orbit.radius) * this.container.retina.pixelRatio;
-        }
-        const modes = options.interactivity.modes;
-        this.connectModeDistance = modes.connect.distance * ratio;
-        this.connectModeRadius = modes.connect.radius * ratio;
-        this.grabModeDistance = modes.grab.distance * ratio;
-        this.repulseModeDistance = modes.repulse.distance * ratio;
-        this.bounceModeDistance = modes.bounce.distance * ratio;
-        this.attractModeDistance = modes.attract.distance * ratio;
-        this.slowModeRadius = modes.slow.radius * ratio;
-        this.bubbleModeDistance = modes.bubble.distance * ratio;
-        if (modes.bubble.size) {
-            this.bubbleModeSize = modes.bubble.size * ratio;
-        }
-    }
-    initParticle(particle) {
-        const options = particle.options;
-        const ratio = this.pixelRatio;
-        const moveDistance = options.move.distance;
-        const props = particle.retina;
-        props.attractDistance = (0, Utils_1.getRangeValue)(options.move.attract.distance) * ratio;
-        props.linksDistance = options.links.distance * ratio;
-        props.linksWidth = options.links.width * ratio;
-        props.moveDrift = (0, Utils_1.getRangeValue)(options.move.drift) * ratio;
-        props.moveSpeed = (0, Utils_1.getRangeValue)(options.move.speed) * ratio;
-        props.sizeAnimationSpeed = (0, Utils_1.getRangeValue)(options.size.animation.speed) * ratio;
-        if (particle.spin) {
-            props.spinAcceleration = (0, Utils_1.getRangeValue)(options.move.spin.acceleration) * ratio;
-        }
-        const maxDistance = props.maxDistance;
-        maxDistance.horizontal = moveDistance.horizontal !== undefined ? moveDistance.horizontal * ratio : undefined;
-        maxDistance.vertical = moveDistance.vertical !== undefined ? moveDistance.vertical * ratio : undefined;
-        props.maxSpeed = (0, Utils_1.getRangeValue)(options.move.gravity.maxSpeed) * ratio;
-    }
-    handleMotionChange(mediaQuery) {
-        const options = this.container.actualOptions;
-        if (mediaQuery.matches) {
-            const motion = options.motion;
-            this.reduceFactor = motion.disable ? 0 : motion.reduce.value ? 1 / motion.reduce.factor : 1;
-        }
-        else {
-            this.reduceFactor = 1;
-        }
-    }
-}
-exports.Retina = Retina;

package/Core/Utils/Circle.d.ts

@@ -1,8 +0,0 @@
-import type { ICoordinates } from "../Interfaces";
-import { Range } from "./Range";
-export declare class Circle extends Range {
-    readonly radius: number;
-    constructor(x: number, y: number, radius: number);
-    contains(point: ICoordinates): boolean;
-    intersects(range: Range): boolean;
-}

package/Core/Utils/Circle.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Circle = void 0;
-const Range_1 = require("./Range");
-const Utils_1 = require("../../Utils");
-class Circle extends Range_1.Range {
-    constructor(x, y, radius) {
-        super(x, y);
-        this.radius = radius;
-    }
-    contains(point) {
-        return (0, Utils_1.getDistance)(point, this.position) <= this.radius;
-    }
-    intersects(range) {
-        const rect = range;
-        const circle = range;
-        const pos1 = this.position;
-        const pos2 = range.position;
-        const xDist = Math.abs(pos2.x - pos1.x);
-        const yDist = Math.abs(pos2.y - pos1.y);
-        const r = this.radius;
-        if (circle.radius !== undefined) {
-            const rSum = r + circle.radius;
-            const dist = Math.sqrt(xDist * xDist + yDist + yDist);
-            return rSum > dist;
-        }
-        else if (rect.size !== undefined) {
-            const w = rect.size.width;
-            const h = rect.size.height;
-            const edges = Math.pow(xDist - w, 2) + Math.pow(yDist - h, 2);
-            if (xDist > r + w || yDist > r + h) {
-                return false;
-            }
-            if (xDist <= w || yDist <= h) {
-                return true;
-            }
-            return edges <= r * r;
-        }
-        return false;
-    }
-}
-exports.Circle = Circle;

package/Core/Utils/CircleWarp.d.ts

@@ -1,9 +0,0 @@
-import type { ICoordinates, IDimension } from "../Interfaces";
-import { Circle } from "./Circle";
-import { Range } from "./Range";
-export declare class CircleWarp extends Circle {
-    private readonly canvasSize;
-    constructor(x: number, y: number, radius: number, canvasSize: IDimension);
-    contains(point: ICoordinates): boolean;
-    intersects(range: Range): boolean;
-}

package/Core/Utils/CircleWarp.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CircleWarp = void 0;
-const Circle_1 = require("./Circle");
-const Rectangle_1 = require("./Rectangle");
-class CircleWarp extends Circle_1.Circle {
-    constructor(x, y, radius, canvasSize) {
-        super(x, y, radius);
-        this.canvasSize = canvasSize;
-        this.canvasSize = {
-            height: canvasSize.height,
-            width: canvasSize.width,
-        };
-    }
-    contains(point) {
-        if (super.contains(point)) {
-            return true;
-        }
-        const posNE = {
-            x: point.x - this.canvasSize.width,
-            y: point.y,
-        };
-        if (super.contains(posNE)) {
-            return true;
-        }
-        const posSE = {
-            x: point.x - this.canvasSize.width,
-            y: point.y - this.canvasSize.height,
-        };
-        if (super.contains(posSE)) {
-            return true;
-        }
-        const posSW = {
-            x: point.x,
-            y: point.y - this.canvasSize.height,
-        };
-        return super.contains(posSW);
-    }
-    intersects(range) {
-        if (super.intersects(range)) {
-            return true;
-        }
-        const rect = range;
-        const circle = range;
-        const newPos = {
-            x: range.position.x - this.canvasSize.width,
-            y: range.position.y - this.canvasSize.height,
-        };
-        if (circle.radius !== undefined) {
-            const biggerCircle = new Circle_1.Circle(newPos.x, newPos.y, circle.radius * 2);
-            return super.intersects(biggerCircle);
-        }
-        else if (rect.size !== undefined) {
-            const rectSW = new Rectangle_1.Rectangle(newPos.x, newPos.y, rect.size.width * 2, rect.size.height * 2);
-            return super.intersects(rectSW);
-        }
-        return false;
-    }
-}
-exports.CircleWarp = CircleWarp;