tsparticles 1.38.0 → 1.39.0

package/Plugins/PolygonMask/Enums/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./InlineArrangement";
-export * from "./MoveType";
-export * from "./Type";
+export * from "./PolygonMaskInlineArrangement";
+export * from "./PolygonMaskMoveType";
+export * from "./PolygonMaskType";

package/Plugins/PolygonMask/Enums/index.js

@@ -10,6 +10,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./InlineArrangement"), exports);
-__exportStar(require("./MoveType"), exports);
-__exportStar(require("./Type"), exports);
+__exportStar(require("./PolygonMaskInlineArrangement"), exports);
+__exportStar(require("./PolygonMaskMoveType"), exports);
+__exportStar(require("./PolygonMaskType"), exports);

package/Plugins/PolygonMask/Options/Classes/PolygonMask.d.ts

@@ -1,24 +1,24 @@
 import type { IPolygonMask } from "../Interfaces/IPolygonMask";
-import { InlineArrangement, InlineArrangementAlt, Type } from "../../Enums";
-import { Draw } from "./Draw";
-import { Move } from "./Move";
-import { Inline } from "./Inline";
+import { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt, PolygonMaskType } from "../../Enums";
+import { PolygonMaskDraw } from "./PolygonMaskDraw";
+import { PolygonMaskMove } from "./PolygonMaskMove";
+import { PolygonMaskInline } from "./PolygonMaskInline";
 import type { RecursivePartial } from "../../../../Types";
-import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
-import { LocalSvg } from "./LocalSvg";
+import type { ICoordinates } from "../../../../Core";
+import { PolygonMaskLocalSvg } from "./PolygonMaskLocalSvg";
 import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
 export declare class PolygonMask implements IPolygonMask, IOptionLoader<IPolygonMask> {
-    get inlineArrangement(): InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt;
-    set inlineArrangement(value: InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt);
-    draw: Draw;
+    get inlineArrangement(): PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    set inlineArrangement(value: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt);
+    draw: PolygonMaskDraw;
     enable: boolean;
-    inline: Inline;
-    move: Move;
+    inline: PolygonMaskInline;
+    move: PolygonMaskMove;
     position?: ICoordinates;
     scale: number;
-    type: Type;
+    type: PolygonMaskType;
     url?: string;
-    data?: string | LocalSvg;
+    data?: string | PolygonMaskLocalSvg;
     constructor();
     load(data?: RecursivePartial<IPolygonMask>): void;
 }

package/Plugins/PolygonMask/Options/Classes/PolygonMask.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolygonMask = void 0;
-const Enums_1 = require("../../Enums");
-const Draw_1 = require("./Draw");
-const Move_1 = require("./Move");
-const Inline_1 = require("./Inline");
-const LocalSvg_1 = require("./LocalSvg");
+const PolygonMaskDraw_1 = require("./PolygonMaskDraw");
+const PolygonMaskMove_1 = require("./PolygonMaskMove");
+const PolygonMaskInline_1 = require("./PolygonMaskInline");
+const PolygonMaskLocalSvg_1 = require("./PolygonMaskLocalSvg");
 const Utils_1 = require("../../../../Utils");
 class PolygonMask {
     constructor() {
-        this.draw = new Draw_1.Draw();
+        this.draw = new PolygonMaskDraw_1.PolygonMaskDraw();
         this.enable = false;
-        this.inline = new Inline_1.Inline();
-        this.move = new Move_1.Move();
+        this.inline = new PolygonMaskInline_1.PolygonMaskInline();
+        this.move = new PolygonMaskMove_1.PolygonMaskMove();
         this.scale = 1;
-        this.type = Enums_1.Type.none;
+        this.type = "none";
     }
     get inlineArrangement() {
         return this.inline.arrangement;
@@ -24,43 +23,44 @@ class PolygonMask {
     }
     load(data) {
         var _a;
-        if (data !== undefined) {
-            this.draw.load(data.draw);
-            const inline = (_a = data.inline) !== null && _a !== void 0 ? _a : {
-                arrangement: data.inlineArrangement,
-            };
-            if (inline !== undefined) {
-                this.inline.load(inline);
-            }
-            this.move.load(data.move);
-            if (data.scale !== undefined) {
-                this.scale = data.scale;
-            }
-            if (data.type !== undefined) {
-                this.type = data.type;
-            }
-            if (data.enable !== undefined) {
-                this.enable = data.enable;
+        if (!data) {
+            return;
+        }
+        this.draw.load(data.draw);
+        const inline = (_a = data.inline) !== null && _a !== void 0 ? _a : {
+            arrangement: data.inlineArrangement,
+        };
+        if (inline !== undefined) {
+            this.inline.load(inline);
+        }
+        this.move.load(data.move);
+        if (data.scale !== undefined) {
+            this.scale = data.scale;
+        }
+        if (data.type !== undefined) {
+            this.type = data.type;
+        }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        else {
+            this.enable = this.type !== "none";
+        }
+        if (data.url !== undefined) {
+            this.url = data.url;
+        }
+        if (data.data !== undefined) {
+            if (typeof data.data === "string") {
+                this.data = data.data;
             }
             else {
-                this.enable = this.type !== Enums_1.Type.none;
-            }
-            if (data.url !== undefined) {
-                this.url = data.url;
-            }
-            if (data.data !== undefined) {
-                if (typeof data.data === "string") {
-                    this.data = data.data;
-                }
-                else {
-                    this.data = new LocalSvg_1.LocalSvg();
-                    this.data.load(data.data);
-                }
-            }
-            if (data.position !== undefined) {
-                this.position = (0, Utils_1.deepExtend)({}, data.position);
+                this.data = new PolygonMaskLocalSvg_1.PolygonMaskLocalSvg();
+                this.data.load(data.data);
             }
         }
+        if (data.position !== undefined) {
+            this.position = (0, Utils_1.deepExtend)({}, data.position);
+        }
     }
 }
 exports.PolygonMask = PolygonMask;

package/Plugins/PolygonMask/Options/Classes/{Draw.d.ts → PolygonMaskDraw.d.ts}

@@ -1,15 +1,15 @@
-import type { IDraw } from "../Interfaces/IDraw";
-import { DrawStroke } from "./DrawStroke";
+import type { IPolygonMaskDraw } from "../Interfaces/IPolygonMaskDraw";
+import { PolygonMaskDrawStroke } from "./PolygonMaskDrawStroke";
 import type { RecursivePartial } from "../../../../Types";
 import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
 import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
-export declare class Draw implements IDraw, IOptionLoader<IDraw> {
+export declare class PolygonMaskDraw implements IPolygonMaskDraw, IOptionLoader<IPolygonMaskDraw> {
     get lineWidth(): number;
     set lineWidth(value: number);
     get lineColor(): string | OptionsColor;
     set lineColor(value: string | OptionsColor);
     enable: boolean;
-    stroke: DrawStroke;
+    stroke: PolygonMaskDrawStroke;
     constructor();
-    load(data?: RecursivePartial<IDraw>): void;
+    load(data?: RecursivePartial<IPolygonMaskDraw>): void;
 }

package/Plugins/PolygonMask/Options/Classes/{Draw.js → PolygonMaskDraw.js}

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Draw = void 0;
-const DrawStroke_1 = require("./DrawStroke");
+exports.PolygonMaskDraw = void 0;
+const PolygonMaskDrawStroke_1 = require("./PolygonMaskDrawStroke");
 const OptionsColor_1 = require("../../../../Options/Classes/OptionsColor");
-class Draw {
+class PolygonMaskDraw {
     constructor() {
         this.enable = false;
-        this.stroke = new DrawStroke_1.DrawStroke();
+        this.stroke = new PolygonMaskDrawStroke_1.PolygonMaskDrawStroke();
     }
     get lineWidth() {
         return this.stroke.width;
@@ -22,16 +22,17 @@ class Draw {
     }
     load(data) {
         var _a;
-        if (data !== undefined) {
-            if (data.enable !== undefined) {
-                this.enable = data.enable;
-            }
-            const stroke = (_a = data.stroke) !== null && _a !== void 0 ? _a : {
-                color: data.lineColor,
-                width: data.lineWidth,
-            };
-            this.stroke.load(stroke);
+        if (!data) {
+            return;
         }
+        if (data.enable !== undefined) {
+            this.enable = data.enable;
+        }
+        const stroke = (_a = data.stroke) !== null && _a !== void 0 ? _a : {
+            color: data.lineColor,
+            width: data.lineWidth,
+        };
+        this.stroke.load(stroke);
     }
 }
-exports.Draw = Draw;
+exports.PolygonMaskDraw = PolygonMaskDraw;

package/Plugins/PolygonMask/Options/Classes/{DrawStroke.d.ts → PolygonMaskDrawStroke.d.ts}

@@ -1,11 +1,11 @@
-import type { IDrawStroke } from "../Interfaces/IDrawStroke";
+import type { IPolygonMaskDrawStroke } from "../Interfaces/IPolygonMaskDrawStroke";
 import type { RecursivePartial } from "../../../../Types";
 import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
 import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
-export declare class DrawStroke implements IDrawStroke, IOptionLoader<IDrawStroke> {
+export declare class PolygonMaskDrawStroke implements IPolygonMaskDrawStroke, IOptionLoader<IPolygonMaskDrawStroke> {
     color: OptionsColor;
     width: number;
     opacity: number;
     constructor();
-    load(data?: RecursivePartial<IDrawStroke>): void;
+    load(data?: RecursivePartial<IPolygonMaskDrawStroke>): void;
 }

package/Plugins/PolygonMask/Options/Classes/PolygonMaskDrawStroke.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolygonMaskDrawStroke = void 0;
+const OptionsColor_1 = require("../../../../Options/Classes/OptionsColor");
+const Utils_1 = require("../../../../Utils");
+class PolygonMaskDrawStroke {
+    constructor() {
+        this.color = new OptionsColor_1.OptionsColor();
+        this.width = 0.5;
+        this.opacity = 1;
+    }
+    load(data) {
+        var _a;
+        if (!data) {
+            return;
+        }
+        this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+        if (typeof this.color.value === "string") {
+            this.opacity = (_a = (0, Utils_1.stringToAlpha)(this.color.value)) !== null && _a !== void 0 ? _a : this.opacity;
+        }
+        if (data.opacity !== undefined) {
+            this.opacity = data.opacity;
+        }
+        if (data.width !== undefined) {
+            this.width = data.width;
+        }
+    }
+}
+exports.PolygonMaskDrawStroke = PolygonMaskDrawStroke;

package/Plugins/PolygonMask/Options/Classes/PolygonMaskInline.d.ts

@@ -0,0 +1,9 @@
+import type { IPolygonMaskInline } from "../Interfaces/IPolygonMaskInline";
+import { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt } from "../../Enums";
+import type { RecursivePartial } from "../../../../Types";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+export declare class PolygonMaskInline implements IPolygonMaskInline, IOptionLoader<IPolygonMaskInline> {
+    arrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskInline>): void;
+}

package/Plugins/PolygonMask/Options/Classes/PolygonMaskInline.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolygonMaskInline = void 0;
+class PolygonMaskInline {
+    constructor() {
+        this.arrangement = "one-per-point";
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.arrangement !== undefined) {
+            this.arrangement = data.arrangement;
+        }
+    }
+}
+exports.PolygonMaskInline = PolygonMaskInline;

package/Plugins/PolygonMask/Options/Classes/PolygonMaskLocalSvg.d.ts

@@ -0,0 +1,11 @@
+import type { IPolygonMaskLocalSvg } from "../Interfaces/IPolygonMaskLocalSvg";
+import type { SingleOrMultiple } from "../../../../Types";
+import type { IDimension } from "../../../../Core";
+import type { RecursivePartial } from "../../../../Types";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+export declare class PolygonMaskLocalSvg implements IPolygonMaskLocalSvg, IOptionLoader<IPolygonMaskLocalSvg> {
+    path: SingleOrMultiple<string>;
+    size: IDimension;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskLocalSvg>): void;
+}

package/Plugins/PolygonMask/Options/Classes/PolygonMaskLocalSvg.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolygonMaskLocalSvg = void 0;
+class PolygonMaskLocalSvg {
+    constructor() {
+        this.path = [];
+        this.size = {
+            height: 0,
+            width: 0,
+        };
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.path !== undefined) {
+            this.path = data.path;
+        }
+        if (data.size !== undefined) {
+            if (data.size.width !== undefined) {
+                this.size.width = data.size.width;
+            }
+            if (data.size.height !== undefined) {
+                this.size.height = data.size.height;
+            }
+        }
+    }
+}
+exports.PolygonMaskLocalSvg = PolygonMaskLocalSvg;

package/Plugins/PolygonMask/Options/Classes/PolygonMaskMove.d.ts

@@ -0,0 +1,10 @@
+import type { IPolygonMaskMove } from "../Interfaces/IPolygonMaskMove";
+import type { RecursivePartial } from "../../../../Types";
+import { PolygonMaskMoveType } from "../../Enums";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+export declare class PolygonMaskMove implements IPolygonMaskMove, IOptionLoader<IPolygonMaskMove> {
+    radius: number;
+    type: PolygonMaskMoveType | keyof typeof PolygonMaskMoveType;
+    constructor();
+    load(data?: RecursivePartial<IPolygonMaskMove>): void;
+}

package/Plugins/PolygonMask/Options/Classes/PolygonMaskMove.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolygonMaskMove = void 0;
+class PolygonMaskMove {
+    constructor() {
+        this.radius = 10;
+        this.type = "path";
+    }
+    load(data) {
+        if (!data) {
+            return;
+        }
+        if (data.radius !== undefined) {
+            this.radius = data.radius;
+        }
+        if (data.type !== undefined) {
+            this.type = data.type;
+        }
+    }
+}
+exports.PolygonMaskMove = PolygonMaskMove;

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMask.d.ts

@@ -1,19 +1,18 @@
-import type { IDraw } from "./IDraw";
-import type { IMove } from "./IMove";
-import type { InlineArrangement, InlineArrangementAlt } from "../../Enums";
-import type { IInline } from "./IInline";
-import type { ICoordinates } from "../../../../Core/Interfaces/ICoordinates";
-import type { ILocalSvg } from "./ILocalSvg";
-import { Type } from "../../Enums";
+import type { IPolygonMaskDraw } from "./IPolygonMaskDraw";
+import type { IPolygonMaskMove } from "./IPolygonMaskMove";
+import type { PolygonMaskType, PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt } from "../../Enums";
+import type { IPolygonMaskInline } from "./IPolygonMaskInline";
+import type { ICoordinates } from "../../../../Core";
+import type { IPolygonMaskLocalSvg } from "./IPolygonMaskLocalSvg";
 export interface IPolygonMask {
-    draw: IDraw;
+    draw: IPolygonMaskDraw;
     enable: boolean;
-    inline: IInline;
-    inlineArrangement: InlineArrangement | keyof typeof InlineArrangement | InlineArrangementAlt;
-    move: IMove;
+    inline: IPolygonMaskInline;
+    inlineArrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+    move: IPolygonMaskMove;
     position?: ICoordinates;
     scale: number;
-    type: Type;
+    type: PolygonMaskType;
     url?: string;
-    data?: string | ILocalSvg;
+    data?: string | IPolygonMaskLocalSvg;
 }

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDraw.d.ts

@@ -0,0 +1,8 @@
+import type { IPolygonMaskDrawStroke } from "./IPolygonMaskDrawStroke";
+import type { IColor } from "../../../../Core";
+export interface IPolygonMaskDraw {
+    enable: boolean;
+    lineColor: string | IColor;
+    lineWidth: number;
+    stroke: IPolygonMaskDrawStroke;
+}

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskDrawStroke.d.ts

@@ -0,0 +1,6 @@
+import type { IColor } from "../../../../Core";
+export interface IPolygonMaskDrawStroke {
+    color: string | IColor;
+    width: number;
+    opacity: number;
+}

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskInline.d.ts

@@ -0,0 +1,4 @@
+import type { PolygonMaskInlineArrangement, PolygonMaskInlineArrangementAlt } from "../../Enums";
+export interface IPolygonMaskInline {
+    arrangement: PolygonMaskInlineArrangement | keyof typeof PolygonMaskInlineArrangement | PolygonMaskInlineArrangementAlt;
+}

package/Plugins/PolygonMask/Options/Interfaces/{ILocalSvg.d.ts → IPolygonMaskLocalSvg.d.ts}

@@ -1,6 +1,6 @@
 import type { SingleOrMultiple } from "../../../../Types";
-import type { IDimension } from "../../../../Core/Interfaces/IDimension";
-export interface ILocalSvg {
+import type { IDimension } from "../../../../Core";
+export interface IPolygonMaskLocalSvg {
     path: SingleOrMultiple<string>;
     size: IDimension;
 }

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskLocalSvg.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskMove.d.ts

@@ -0,0 +1,5 @@
+import type { PolygonMaskMoveType } from "../../Enums";
+export interface IPolygonMaskMove {
+    radius: number;
+    type: PolygonMaskMoveType | keyof typeof PolygonMaskMoveType;
+}

package/Plugins/PolygonMask/Options/Interfaces/IPolygonMaskMove.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/Plugins/PolygonMask/PolygonMaskInstance.d.ts

@@ -1,11 +1,9 @@
-import type { Container } from "../../Core/Container";
-import type { IContainerPlugin, ICoordinates, IDelta, IDimension } from "../../Core/Interfaces";
-import { Particle } from "../../Core/Particle";
+import type { Container, IContainerPlugin, ICoordinates, IDelta, IDimension, Particle } from "../../Core";
 import type { ISvgPath } from "./Interfaces/ISvgPath";
 import type { RecursivePartial } from "../../Types";
 import { PolygonMask } from "./Options/Classes/PolygonMask";
 import { OutModeDirection } from "../../Enums";
-import type { IPolygonMaskOptions } from "./types";
+import type { IPolygonMaskOptions } from "./Types";
 export declare class PolygonMaskInstance implements IContainerPlugin {
     private readonly container;
     redrawTimeout?: number;