tsparticles 1.38.0 → 1.39.0

package/esm/Shapes/Image/ImageDrawer.js

@@ -10,9 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ImageDrawer_images;
-import { isInArray } from "../../Utils";
-import { ShapeType } from "../../Enums";
-import { downloadSvgImage, loadImage, replaceColorSvg } from "./Utils";
+import { downloadSvgImage, loadImage, replaceImageColor } from "./Utils";
 export class ImageDrawer {
     constructor() {
         _ImageDrawer_images.set(this, void 0);
@@ -38,86 +36,31 @@ export class ImageDrawer {
         const containerImages = this.getImages(container);
         containerImages === null || containerImages === void 0 ? void 0 : containerImages.images.push(image);
     }
-    async init(container) {
-        await this.loadImagesFromParticlesOptions(container, container.actualOptions.particles);
-        await this.loadImagesFromParticlesOptions(container, container.actualOptions.interactivity.modes.trail.particles);
-        for (const manualParticle of container.actualOptions.manualParticles) {
-            await this.loadImagesFromParticlesOptions(container, manualParticle.options);
-        }
-        const emitterOptions = container.actualOptions;
-        if (emitterOptions.emitters) {
-            if (emitterOptions.emitters instanceof Array) {
-                for (const emitter of emitterOptions.emitters) {
-                    await this.loadImagesFromParticlesOptions(container, emitter.particles);
-                }
-            }
-            else {
-                await this.loadImagesFromParticlesOptions(container, emitterOptions.emitters.particles);
-            }
-        }
-        const interactiveEmitters = emitterOptions.interactivity.modes.emitters;
-        if (interactiveEmitters) {
-            if (interactiveEmitters instanceof Array) {
-                for (const emitter of interactiveEmitters) {
-                    await this.loadImagesFromParticlesOptions(container, emitter.particles);
-                }
-            }
-            else {
-                await this.loadImagesFromParticlesOptions(container, interactiveEmitters.particles);
-            }
-        }
-    }
     destroy() {
         __classPrivateFieldSet(this, _ImageDrawer_images, [], "f");
     }
-    async loadImagesFromParticlesOptions(container, options) {
-        var _a, _b, _c;
-        const shapeOptions = options === null || options === void 0 ? void 0 : options.shape;
-        if (!(shapeOptions === null || shapeOptions === void 0 ? void 0 : shapeOptions.type) ||
-            !shapeOptions.options ||
-            (!isInArray(ShapeType.image, shapeOptions.type) && !isInArray(ShapeType.images, shapeOptions.type))) {
-            return;
-        }
-        const idx = __classPrivateFieldGet(this, _ImageDrawer_images, "f").findIndex((t) => t.id === container.id);
-        if (idx >= 0) {
-            __classPrivateFieldGet(this, _ImageDrawer_images, "f").splice(idx, 1);
-        }
-        const imageOptions = (_a = shapeOptions.options[ShapeType.images]) !== null && _a !== void 0 ? _a : shapeOptions.options[ShapeType.image];
-        if (imageOptions instanceof Array) {
-            for (const optionsImage of imageOptions) {
-                await this.loadImageShape(container, optionsImage);
-            }
-        }
-        else {
-            await this.loadImageShape(container, imageOptions);
-        }
-        if (options === null || options === void 0 ? void 0 : options.groups) {
-            for (const groupName in options.groups) {
-                const group = options.groups[groupName];
-                await this.loadImagesFromParticlesOptions(container, group);
-            }
-        }
-        if ((_c = (_b = options === null || options === void 0 ? void 0 : options.destroy) === null || _b === void 0 ? void 0 : _b.split) === null || _c === void 0 ? void 0 : _c.particles) {
-            await this.loadImagesFromParticlesOptions(container, options === null || options === void 0 ? void 0 : options.destroy.split.particles);
-        }
-    }
     async loadImageShape(container, imageShape) {
+        const source = imageShape.src;
+        if (!source) {
+            throw new Error("Error tsParticles - No image.src");
+        }
         try {
+            const image = {
+                source: source,
+                type: source.substr(source.length - 3),
+                error: false,
+                loading: true,
+            };
+            this.addImage(container, image);
             const imageFunc = imageShape.replaceColor ? downloadSvgImage : loadImage;
-            const image = await imageFunc(imageShape.src);
-            if (image) {
-                this.addImage(container, image);
-            }
+            await imageFunc(image);
         }
         catch (_a) {
-            console.warn(`tsParticles error - ${imageShape.src} not found`);
+            throw new Error(`tsParticles error - ${imageShape.src} not found`);
         }
     }
     draw(context, particle, radius, opacity) {
         var _a, _b;
-        if (!context) {
-            return;
-        }
         const image = particle.image;
         const element = (_a = image === null || image === void 0 ? void 0 : image.data) === null || _a === void 0 ? void 0 : _a.element;
         if (!element) {
@@ -137,64 +80,41 @@ export class ImageDrawer {
         }
     }
     loadShape(particle) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c;
         if (particle.shape !== "image" && particle.shape !== "images") {
             return;
         }
         const images = this.getImages(particle.container).images;
         const imageData = particle.shapeData;
-        const image = (_a = images.find((t) => t.source === imageData.src)) !== null && _a !== void 0 ? _a : images[0];
-        const color = particle.getFillColor();
+        const image = images.find((t) => t.source === imageData.src);
         let imageRes;
         if (!image) {
+            this.loadImageShape(particle.container, imageData).then(() => {
+                this.loadShape(particle);
+            });
             return;
         }
-        if (image.svgData !== undefined && imageData.replaceColor && color) {
-            const svgColoredData = replaceColorSvg(image, color, (_c = (_b = particle.opacity) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : 1);
-            const svg = new Blob([svgColoredData], { type: "image/svg+xml" });
-            const domUrl = URL || window.URL || window.webkitURL || window;
-            const url = domUrl.createObjectURL(svg);
-            const img = new Image();
-            imageRes = {
-                data: Object.assign(Object.assign({}, image), { svgData: svgColoredData }),
-                ratio: imageData.width / imageData.height,
-                replaceColor: (_d = imageData.replaceColor) !== null && _d !== void 0 ? _d : imageData.replace_color,
-                source: imageData.src,
-            };
-            img.addEventListener("load", () => {
-                const pImage = particle.image;
-                if (pImage) {
-                    pImage.loaded = true;
-                    image.element = img;
-                }
-                domUrl.revokeObjectURL(url);
-            });
-            img.addEventListener("error", () => {
-                domUrl.revokeObjectURL(url);
-                loadImage(imageData.src).then((img2) => {
-                    const pImage = particle.image;
-                    if (pImage) {
-                        image.element = img2 === null || img2 === void 0 ? void 0 : img2.element;
-                        pImage.loaded = true;
-                    }
-                });
-            });
-            img.src = url;
+        if (image.error) {
+            return;
+        }
+        const color = particle.getFillColor();
+        if (image.svgData && imageData.replaceColor && color) {
+            imageRes = replaceImageColor(image, imageData, color, particle);
         }
         else {
             imageRes = {
                 data: image,
                 loaded: true,
                 ratio: imageData.width / imageData.height,
-                replaceColor: (_e = imageData.replaceColor) !== null && _e !== void 0 ? _e : imageData.replace_color,
+                replaceColor: (_a = imageData.replaceColor) !== null && _a !== void 0 ? _a : imageData.replace_color,
                 source: imageData.src,
             };
         }
         if (!imageRes.ratio) {
             imageRes.ratio = 1;
         }
-        const fill = (_f = imageData.fill) !== null && _f !== void 0 ? _f : particle.fill;
-        const close = (_g = imageData.close) !== null && _g !== void 0 ? _g : particle.close;
+        const fill = (_b = imageData.fill) !== null && _b !== void 0 ? _b : particle.fill;
+        const close = (_c = imageData.close) !== null && _c !== void 0 ? _c : particle.close;
         const imageShape = {
             image: imageRes,
             fill,

package/esm/Shapes/Image/Utils.d.ts

@@ -1,9 +1,12 @@
-import type { IHsl, IParticle } from "../../Core/Interfaces";
+import type { IHsl, IParticle, Particle } from "../../Core";
+import type { IImageShape } from "../../Options/Interfaces/Particles/Shape/IImageShape";
 export interface IImage {
     source: string;
     type: string;
     element?: HTMLImageElement;
     svgData?: string;
+    error: boolean;
+    loading: boolean;
 }
 export interface IParticleImage {
     source: string;
@@ -18,8 +21,8 @@ export interface ContainerImage {
     images: IImage[];
 }
 export declare type IImageParticle = IParticle & {
-    image: IParticleImage;
+    image?: IParticleImage;
 };
-export declare function loadImage(source: string): Promise<IImage | undefined>;
-export declare function downloadSvgImage(source: string): Promise<IImage | undefined>;
-export declare function replaceColorSvg(imageShape: IImage, color: IHsl, opacity: number): string;
+export declare function loadImage(image: IImage): Promise<void>;
+export declare function downloadSvgImage(image: IImage): Promise<void>;
+export declare function replaceImageColor(image: IImage, imageData: IImageShape, color: IHsl, particle: Particle): IParticleImage;

package/esm/Shapes/Image/Utils.js

@@ -1,52 +1,83 @@
 import { getStyleFromHsl } from "../../Utils";
-export function loadImage(source) {
-    return new Promise((resolve, reject) => {
-        if (!source) {
-            reject("Error tsParticles - No image.src");
-            return;
-        }
-        const image = {
-            source: source,
-            type: source.substr(source.length - 3),
-        };
+const currentColorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
+function replaceColorSvg(imageShape, color, opacity) {
+    const { svgData } = imageShape;
+    if (!svgData) {
+        return "";
+    }
+    const colorStyle = getStyleFromHsl(color, opacity);
+    if (svgData.includes("fill")) {
+        return svgData.replace(currentColorRegex, () => colorStyle);
+    }
+    const preFillIndex = svgData.indexOf(">");
+    return `${svgData.substring(0, preFillIndex)} fill="${colorStyle}"${svgData.substring(preFillIndex)}`;
+}
+export async function loadImage(image) {
+    return new Promise((resolve) => {
+        image.loading = true;
         const img = new Image();
         img.addEventListener("load", () => {
             image.element = img;
-            resolve(image);
+            image.loading = false;
+            resolve();
         });
         img.addEventListener("error", () => {
-            reject(`Error tsParticles - loading image: ${source}`);
+            image.error = true;
+            image.loading = false;
+            console.error(`Error tsParticles - loading image: ${image.source}`);
+            resolve();
         });
-        img.src = source;
+        img.src = image.source;
     });
 }
-export async function downloadSvgImage(source) {
-    if (!source) {
-        throw new Error("Error tsParticles - No image.src");
-    }
-    const image = {
-        source: source,
-        type: source.substr(source.length - 3),
-    };
+export async function downloadSvgImage(image) {
     if (image.type !== "svg") {
-        return loadImage(source);
+        await loadImage(image);
+        return;
     }
+    image.loading = true;
     const response = await fetch(image.source);
+    image.loading = false;
     if (!response.ok) {
-        throw new Error("Error tsParticles - Image not found");
+        console.error("Error tsParticles - Image not found");
+        image.error = true;
     }
-    image.svgData = await response.text();
-    return image;
-}
-export function replaceColorSvg(imageShape, color, opacity) {
-    const { svgData } = imageShape;
-    if (!svgData) {
-        return "";
-    }
-    if (svgData.includes("fill")) {
-        const currentColor = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
-        return svgData.replace(currentColor, () => getStyleFromHsl(color, opacity));
+    if (!image.error) {
+        image.svgData = await response.text();
     }
-    const preFillIndex = svgData.indexOf(">");
-    return `${svgData.substring(0, preFillIndex)} fill="${getStyleFromHsl(color, opacity)}"${svgData.substring(preFillIndex)}`;
+}
+export function replaceImageColor(image, imageData, color, particle) {
+    var _a, _b, _c;
+    const svgColoredData = replaceColorSvg(image, color, (_b = (_a = particle.opacity) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 1);
+    const svg = new Blob([svgColoredData], { type: "image/svg+xml" });
+    const domUrl = URL || window.URL || window.webkitURL || window;
+    const url = domUrl.createObjectURL(svg);
+    const img = new Image();
+    const imageRes = {
+        data: Object.assign(Object.assign({}, image), { svgData: svgColoredData }),
+        ratio: imageData.width / imageData.height,
+        replaceColor: (_c = imageData.replaceColor) !== null && _c !== void 0 ? _c : imageData.replace_color,
+        source: imageData.src,
+    };
+    img.addEventListener("load", () => {
+        const pImage = particle.image;
+        if (pImage) {
+            pImage.loaded = true;
+            image.element = img;
+        }
+        domUrl.revokeObjectURL(url);
+    });
+    img.addEventListener("error", () => {
+        domUrl.revokeObjectURL(url);
+        const img2 = Object.assign(Object.assign({}, image), { error: false, loading: true });
+        loadImage(img2).then(() => {
+            const pImage = particle.image;
+            if (pImage) {
+                image.element = img2.element;
+                pImage.loaded = true;
+            }
+        });
+    });
+    img.src = url;
+    return imageRes;
 }

package/esm/Shapes/Image/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadImageShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadImageShape(tsParticles: Engine): Promise<void>;

package/esm/Shapes/Line/LineDrawer.d.ts

@@ -1,4 +1,4 @@
-import { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class LineDrawer implements IShapeDrawer {
     getSidesCount(): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

package/esm/Shapes/Line/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadLineShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadLineShape(tsParticles: Engine): Promise<void>;

package/esm/Shapes/Polygon/PolygonDrawer.d.ts

@@ -1,6 +1,6 @@
 import type { ISide } from "./PolygonDrawerBase";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle } from "../../Core";
 export declare class PolygonDrawer extends PolygonDrawerBase {
     getSidesData(particle: IParticle, radius: number): ISide;
     getCenter(particle: IParticle, radius: number): ICoordinates;

package/esm/Shapes/Polygon/PolygonDrawerBase.d.ts

@@ -1,4 +1,4 @@
-import type { ICoordinates, IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle, IShapeDrawer } from "../../Core";
 export interface ISideCount {
     numerator: number;
     denominator: number;

package/esm/Shapes/Polygon/TriangleDrawer.d.ts

@@ -1,5 +1,5 @@
 import type { ISide } from "./PolygonDrawerBase";
-import type { ICoordinates, IParticle } from "../../Core/Interfaces";
+import type { ICoordinates, IParticle } from "../../Core";
 import { PolygonDrawerBase } from "./PolygonDrawerBase";
 export declare class TriangleDrawer extends PolygonDrawerBase {
     getSidesCount(): number;

package/esm/Shapes/Polygon/index.d.ts

@@ -1,4 +1,4 @@
-import type { Main } from "../../main";
-export declare function loadGenericPolygonShape(tsParticles: Main): Promise<void>;
-export declare function loadTriangleShape(tsParticles: Main): Promise<void>;
-export declare function loadPolygonShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadGenericPolygonShape(tsParticles: Engine): Promise<void>;
+export declare function loadTriangleShape(tsParticles: Engine): Promise<void>;
+export declare function loadPolygonShape(tsParticles: Engine): Promise<void>;

package/esm/Shapes/Square/SquareDrawer.d.ts

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class SquareDrawer implements IShapeDrawer {
     getSidesCount(): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

package/esm/Shapes/Square/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadSquareShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadSquareShape(tsParticles: Engine): Promise<void>;

package/esm/Shapes/Star/StarDrawer.d.ts

@@ -1,4 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
+import type { IParticle, IShapeDrawer } from "../../Core";
 export declare class StarDrawer implements IShapeDrawer {
     getSidesCount(particle: IParticle): number;
     draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;

package/esm/Shapes/Star/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadStarShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadStarShape(tsParticles: Engine): Promise<void>;

package/esm/Shapes/Text/TextDrawer.d.ts

@@ -1,5 +1,4 @@
-import type { IParticle, IShapeDrawer } from "../../Core/Interfaces";
-import type { Container } from "../../Core/Container";
+import type { Container, IParticle, IShapeDrawer } from "../../Core";
 export declare const validTypes: string[];
 export declare class TextDrawer implements IShapeDrawer {
     getSidesCount(): number;

package/esm/Shapes/Text/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadTextShape(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadTextShape(tsParticles: Engine): Promise<void>;

package/esm/Updaters/Angle/AngleUpdater.d.ts

@@ -1,6 +1,4 @@
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import { Particle } from "../../Core/Particle";
-import { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class AngleUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/Angle/AngleUpdater.js

@@ -1,4 +1,3 @@
-import { AnimationStatus, RotateDirection } from "../../Enums";
 import { getRangeValue } from "../../Utils";
 function updateAngle(particle, delta) {
     var _a;
@@ -14,13 +13,13 @@ function updateAngle(particle, delta) {
         return;
     }
     switch (rotate.status) {
-        case AnimationStatus.increasing:
+        case 0:
             rotate.value += speed;
             if (rotate.value > max) {
                 rotate.value -= max;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1:
         default:
             rotate.value -= speed;
             if (rotate.value < 0) {
@@ -40,17 +39,17 @@ export class AngleUpdater {
             value: (getRangeValue(rotateOptions.value) * Math.PI) / 180,
         };
         let rotateDirection = rotateOptions.direction;
-        if (rotateDirection === RotateDirection.random) {
+        if (rotateDirection === "random") {
             const index = Math.floor(Math.random() * 2);
-            rotateDirection = index > 0 ? RotateDirection.counterClockwise : RotateDirection.clockwise;
+            rotateDirection = index > 0 ? "counter-clockwise" : "clockwise";
         }
         switch (rotateDirection) {
-            case RotateDirection.counterClockwise:
+            case "counter-clockwise":
             case "counterClockwise":
-                particle.rotate.status = AnimationStatus.decreasing;
+                particle.rotate.status = 1;
                 break;
-            case RotateDirection.clockwise:
-                particle.rotate.status = AnimationStatus.increasing;
+            case "clockwise":
+                particle.rotate.status = 0;
                 break;
         }
         const rotateAnimation = particle.options.rotate.animation;

package/esm/Updaters/Angle/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadAngleUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadAngleUpdater(tsParticles: Engine): Promise<void>;

package/esm/Updaters/Color/ColorUpdater.d.ts

@@ -1,6 +1,4 @@
-import { Particle } from "../../Core/Particle";
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class ColorUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/Color/ColorUpdater.js

@@ -1,4 +1,3 @@
-import { AnimationStatus } from "../../Enums";
 import { colorToHsl, getHslAnimationFromHsl, randomInRange } from "../../Utils";
 function updateColorValue(delta, value, valueAnimation, max, decrease) {
     var _a;
@@ -8,17 +7,17 @@ function updateColorValue(delta, value, valueAnimation, max, decrease) {
     }
     const offset = randomInRange(valueAnimation.offset);
     const velocity = ((_a = value.velocity) !== null && _a !== void 0 ? _a : 0) * delta.factor + offset * 3.6;
-    if (!decrease || colorValue.status === AnimationStatus.increasing) {
+    if (!decrease || colorValue.status === 0) {
         colorValue.value += velocity;
         if (decrease && colorValue.value > max) {
-            colorValue.status = AnimationStatus.decreasing;
+            colorValue.status = 1;
             colorValue.value -= colorValue.value % max;
         }
     }
     else {
         colorValue.value -= velocity;
         if (colorValue.value < 0) {
-            colorValue.status = AnimationStatus.increasing;
+            colorValue.status = 0;
             colorValue.value += colorValue.value;
         }
     }

package/esm/Updaters/Color/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadColorUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadColorUpdater(tsParticles: Engine): Promise<void>;

package/esm/Updaters/Life/LifeUpdater.d.ts

@@ -1,6 +1,4 @@
-import { Particle } from "../../Core/Particle";
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import type { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class LifeUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/Life/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadLifeUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadLifeUpdater(tsParticles: Engine): Promise<void>;

package/esm/Updaters/Opacity/OpacityUpdater.d.ts

@@ -1,6 +1,4 @@
-import type { Particle } from "../../Core/Particle";
-import type { IDelta, IParticleUpdater } from "../../Core/Interfaces";
-import { Container } from "../../Core/Container";
+import type { Container, IDelta, IParticleUpdater, Particle } from "../../Core";
 export declare class OpacityUpdater implements IParticleUpdater {
     private readonly container;
     constructor(container: Container);

package/esm/Updaters/Opacity/OpacityUpdater.js

@@ -1,13 +1,12 @@
-import { AnimationStatus, DestroyType, StartValueType } from "../../Enums";
 import { clamp, getRangeMax, getRangeMin, getRangeValue, randomInRange } from "../../Utils";
 function checkDestroy(particle, value, minValue, maxValue) {
     switch (particle.options.opacity.animation.destroy) {
-        case DestroyType.max:
+        case "max":
             if (value >= maxValue) {
                 particle.destroy();
             }
             break;
-        case DestroyType.min:
+        case "min":
             if (value <= minValue) {
                 particle.destroy();
             }
@@ -27,9 +26,9 @@ function updateOpacity(particle, delta) {
         return;
     }
     switch (particle.opacity.status) {
-        case AnimationStatus.increasing:
+        case 0:
             if (particle.opacity.value >= maxValue) {
-                particle.opacity.status = AnimationStatus.decreasing;
+                particle.opacity.status = 1;
                 if (!particle.opacity.loops) {
                     particle.opacity.loops = 0;
                 }
@@ -39,9 +38,9 @@ function updateOpacity(particle, delta) {
                 particle.opacity.value += ((_d = particle.opacity.velocity) !== null && _d !== void 0 ? _d : 0) * delta.factor;
             }
             break;
-        case AnimationStatus.decreasing:
+        case 1:
             if (particle.opacity.value <= minValue) {
-                particle.opacity.status = AnimationStatus.increasing;
+                particle.opacity.status = 0;
                 if (!particle.opacity.loops) {
                     particle.opacity.loops = 0;
                 }
@@ -73,24 +72,24 @@ export class OpacityUpdater {
         };
         const opacityAnimation = opacityOptions.animation;
         if (opacityAnimation.enable) {
-            particle.opacity.status = AnimationStatus.increasing;
+            particle.opacity.status = 0;
             const opacityRange = opacityOptions.value;
             particle.opacity.min = getRangeMin(opacityRange);
             particle.opacity.max = getRangeMax(opacityRange);
             switch (opacityAnimation.startValue) {
-                case StartValueType.min:
+                case "min":
                     particle.opacity.value = particle.opacity.min;
-                    particle.opacity.status = AnimationStatus.increasing;
+                    particle.opacity.status = 0;
                     break;
-                case StartValueType.random:
+                case "random":
                     particle.opacity.value = randomInRange(particle.opacity);
                     particle.opacity.status =
-                        Math.random() >= 0.5 ? AnimationStatus.increasing : AnimationStatus.decreasing;
+                        Math.random() >= 0.5 ? 0 : 1;
                     break;
-                case StartValueType.max:
+                case "max":
                 default:
                     particle.opacity.value = particle.opacity.max;
-                    particle.opacity.status = AnimationStatus.decreasing;
+                    particle.opacity.status = 1;
                     break;
             }
             particle.opacity.velocity = (opacityAnimation.speed / 100) * this.container.retina.reduceFactor;

package/esm/Updaters/Opacity/index.d.ts

@@ -1,2 +1,2 @@
-import type { Main } from "../../main";
-export declare function loadOpacityUpdater(tsParticles: Main): Promise<void>;
+import type { Engine } from "../../engine";
+export declare function loadOpacityUpdater(tsParticles: Engine): Promise<void>;