@tsparticles/interaction-particles-links 3.0.0-alpha.0

package/types/ILink.d.ts

@@ -0,0 +1,9 @@
+import type { LinkParticle } from "./LinkParticle";
+export interface ILink {
+    destination: LinkParticle;
+    opacity: number;
+}
+export interface ILinkTriangle {
+    opacity: number;
+    vertices: LinkParticle[];
+}

package/types/LinkContainer.d.ts

@@ -0,0 +1,7 @@
+import type { Container, IRgb } from "@tsparticles/engine";
+export type LinkContainer = Container & {
+    particles: {
+        linksColor?: IRgb | string;
+        linksColors: Map<string, IRgb | string | undefined>;
+    };
+};

package/types/LinkInstance.d.ts

@@ -0,0 +1,17 @@
+import type { IContainerPlugin } from "@tsparticles/engine";
+import type { LinkContainer } from "./LinkContainer";
+import type { LinkParticle } from "./LinkParticle";
+export declare class LinkInstance implements IContainerPlugin {
+    private readonly container;
+    private readonly _freqs;
+    constructor(container: LinkContainer);
+    drawParticle(context: CanvasRenderingContext2D, particle: LinkParticle): void;
+    init(): Promise<void>;
+    particleCreated(particle: LinkParticle): void;
+    particleDestroyed(particle: LinkParticle): void;
+    private drawLinkLine;
+    private drawLinkTriangle;
+    private drawTriangles;
+    private getLinkFrequency;
+    private getTriangleFrequency;
+}

package/types/LinkParticle.d.ts

@@ -0,0 +1,11 @@
+import type { ILink } from "./ILink";
+import type { Particle } from "@tsparticles/engine";
+import type { ParticlesLinkOptions } from "./Options/Classes/ParticlesLinkOptions";
+export type LinkParticle = Particle & {
+    links?: ILink[];
+    options: ParticlesLinkOptions;
+    retina: {
+        linksDistance?: number;
+        linksWidth?: number;
+    };
+};

package/types/Linker.d.ts

@@ -0,0 +1,17 @@
+import { ParticlesInteractorBase } from "@tsparticles/engine";
+import type { RecursivePartial } from "@tsparticles/engine";
+import type { IParticlesLinkOptions } from "./Options/Interfaces/IParticlesLinkOptions";
+import type { LinkContainer } from "./LinkContainer";
+import type { LinkParticle } from "./LinkParticle";
+import type { ParticlesLinkOptions } from "./Options/Classes/ParticlesLinkOptions";
+export declare class Linker extends ParticlesInteractorBase {
+    linkContainer: LinkContainer;
+    constructor(container: LinkContainer);
+    clear(): void;
+    init(): void;
+    interact(p1: LinkParticle): Promise<void>;
+    isEnabled(particle: LinkParticle): boolean;
+    loadParticlesOptions(options: ParticlesLinkOptions, ...sources: (RecursivePartial<IParticlesLinkOptions> | undefined)[]): void;
+    reset(): void;
+    private setColor;
+}

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

@@ -0,0 +1,21 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { ILinks } from "../Interfaces/ILinks";
+import { LinksShadow } from "./LinksShadow";
+import { LinksTriangle } from "./LinksTriangle";
+import { OptionsColor } from "@tsparticles/engine";
+export declare class Links implements ILinks, IOptionLoader<ILinks> {
+    blink: boolean;
+    color: OptionsColor;
+    consent: boolean;
+    distance: number;
+    enable: boolean;
+    frequency: number;
+    id?: string;
+    opacity: number;
+    shadow: LinksShadow;
+    triangles: LinksTriangle;
+    warp: boolean;
+    width: number;
+    constructor();
+    load(data?: RecursivePartial<ILinks>): void;
+}

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

@@ -0,0 +1,10 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { ILinksShadow } from "../Interfaces/ILinksShadow";
+import { OptionsColor } from "@tsparticles/engine";
+export declare class LinksShadow implements ILinksShadow, IOptionLoader<ILinksShadow> {
+    blur: number;
+    color: OptionsColor;
+    enable: boolean;
+    constructor();
+    load(data?: RecursivePartial<ILinksShadow>): void;
+}

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

@@ -0,0 +1,11 @@
+import type { IOptionLoader, RecursivePartial } from "@tsparticles/engine";
+import type { ILinksTriangle } from "../Interfaces/ILinksTriangle";
+import { OptionsColor } from "@tsparticles/engine";
+export declare class LinksTriangle implements ILinksTriangle, IOptionLoader<ILinksTriangle> {
+    color?: OptionsColor;
+    enable: boolean;
+    frequency: number;
+    opacity?: number;
+    constructor();
+    load(data?: RecursivePartial<ILinksTriangle>): void;
+}

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

@@ -0,0 +1,5 @@
+import type { Links } from "./Links";
+import type { ParticlesOptions } from "@tsparticles/engine";
+export type ParticlesLinkOptions = ParticlesOptions & {
+    links?: Links;
+};

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

@@ -0,0 +1,17 @@
+import type { ILinksShadow } from "./ILinksShadow";
+import type { ILinksTriangle } from "./ILinksTriangle";
+import type { IOptionsColor } from "@tsparticles/engine";
+export interface ILinks {
+    blink: boolean;
+    color: string | IOptionsColor;
+    consent: boolean;
+    distance: number;
+    enable: boolean;
+    frequency: number;
+    id?: string;
+    opacity: number;
+    shadow: ILinksShadow;
+    triangles: ILinksTriangle;
+    warp: boolean;
+    width: number;
+}

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

@@ -0,0 +1,6 @@
+import type { IOptionsColor } from "@tsparticles/engine";
+export interface ILinksShadow {
+    blur: number;
+    color: string | IOptionsColor;
+    enable: boolean;
+}

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

@@ -0,0 +1,7 @@
+import type { IOptionsColor } from "@tsparticles/engine";
+export interface ILinksTriangle {
+    color?: string | IOptionsColor;
+    enable: boolean;
+    frequency: number;
+    opacity?: number;
+}

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

@@ -0,0 +1,7 @@
+import type { ILinks } from "./ILinks";
+import type { IParticlesOptions } from "@tsparticles/engine";
+export type IParticlesLinkOptions = IParticlesOptions & {
+    lineLinked?: ILinks;
+    line_linked?: ILinks;
+    links?: ILinks;
+};

package/types/Utils.d.ts

@@ -0,0 +1,4 @@
+import type { ICoordinates, IDimension, IRgb } from "@tsparticles/engine";
+import type { ILinksShadow } from "./Options/Interfaces/ILinksShadow";
+export declare function drawLinkLine(context: CanvasRenderingContext2D, width: number, begin: ICoordinates, end: ICoordinates, maxDistance: number, canvasSize: IDimension, warp: boolean, backgroundMask: boolean, composite: GlobalCompositeOperation, colorLine: IRgb, opacity: number, shadow: ILinksShadow): void;
+export declare function drawLinkTriangle(context: CanvasRenderingContext2D, pos1: ICoordinates, pos2: ICoordinates, pos3: ICoordinates, backgroundMask: boolean, composite: GlobalCompositeOperation, colorTriangle: IRgb, opacityTriangle: number): void;

package/types/index.d.ts

@@ -0,0 +1,8 @@
+import type { Engine } from "@tsparticles/engine";
+export declare function loadParticlesLinksInteraction(engine: Engine): Promise<void>;
+export * from "./Options/Classes/Links";
+export * from "./Options/Classes/LinksShadow";
+export * from "./Options/Classes/LinksTriangle";
+export * from "./Options/Interfaces/ILinks";
+export * from "./Options/Interfaces/ILinksShadow";
+export * from "./Options/Interfaces/ILinksTriangle";

package/types/interaction.d.ts

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

package/types/plugin.d.ts

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

package/umd/CircleWarp.js

@@ -0,0 +1,64 @@
+(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.CircleWarp = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class CircleWarp extends engine_1.Circle {
+        constructor(x, y, radius, canvasSize) {
+            super(x, y, radius);
+            this.canvasSize = canvasSize;
+            this.canvasSize = Object.assign({}, canvasSize);
+        }
+        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, circle = range, newPos = {
+                x: range.position.x - this.canvasSize.width,
+                y: range.position.y - this.canvasSize.height,
+            };
+            if (circle.radius !== undefined) {
+                const biggerCircle = new engine_1.Circle(newPos.x, newPos.y, circle.radius * 2);
+                return super.intersects(biggerCircle);
+            }
+            else if (rect.size !== undefined) {
+                const rectSW = new engine_1.Rectangle(newPos.x, newPos.y, rect.size.width * 2, rect.size.height * 2);
+                return super.intersects(rectSW);
+            }
+            return false;
+        }
+    }
+    exports.CircleWarp = CircleWarp;
+});

package/umd/ILink.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/LinkContainer.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/LinkInstance.js

@@ -0,0 +1,157 @@
+(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", "./Utils", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LinkInstance = void 0;
+    const Utils_1 = require("./Utils");
+    const engine_1 = require("@tsparticles/engine");
+    function getLinkKey(ids) {
+        ids.sort((a, b) => a - b);
+        return ids.join("_");
+    }
+    function setLinkFrequency(particles, dictionary) {
+        const key = getLinkKey(particles.map((t) => t.id));
+        let res = dictionary.get(key);
+        if (res === undefined) {
+            res = (0, engine_1.getRandom)();
+            dictionary.set(key, res);
+        }
+        return res;
+    }
+    class LinkInstance {
+        constructor(container) {
+            this.container = container;
+            this._freqs = {
+                links: new Map(),
+                triangles: new Map(),
+            };
+        }
+        drawParticle(context, particle) {
+            var _a;
+            const pOptions = particle.options;
+            if (!particle.links || particle.links.length <= 0) {
+                return;
+            }
+            const p1Links = particle.links.filter((l) => pOptions.links && this.getLinkFrequency(particle, l.destination) <= pOptions.links.frequency);
+            for (const link of p1Links) {
+                this.drawTriangles(pOptions, particle, link, p1Links);
+                if (link.opacity > 0 && ((_a = particle.retina.linksWidth) !== null && _a !== void 0 ? _a : 0) > 0) {
+                    this.drawLinkLine(particle, link);
+                }
+            }
+        }
+        async init() {
+            this._freqs.links = new Map();
+            this._freqs.triangles = new Map();
+        }
+        particleCreated(particle) {
+            particle.links = [];
+            if (!particle.options.links) {
+                return;
+            }
+            const ratio = this.container.retina.pixelRatio;
+            particle.retina.linksDistance = particle.options.links.distance * ratio;
+            particle.retina.linksWidth = particle.options.links.width * ratio;
+        }
+        particleDestroyed(particle) {
+            particle.links = [];
+        }
+        drawLinkLine(p1, link) {
+            const container = this.container, options = container.actualOptions, p2 = link.destination, pos1 = p1.getPosition(), pos2 = p2.getPosition();
+            let opacity = link.opacity;
+            container.canvas.draw((ctx) => {
+                var _a, _b, _c;
+                if (!p1.options.links) {
+                    return;
+                }
+                let colorLine;
+                const twinkle = (_a = p1.options.twinkle) === null || _a === void 0 ? void 0 : _a.lines;
+                if (twinkle === null || twinkle === void 0 ? void 0 : twinkle.enable) {
+                    const twinkleFreq = twinkle.frequency, twinkleRgb = (0, engine_1.rangeColorToRgb)(twinkle.color), twinkling = (0, engine_1.getRandom)() < twinkleFreq;
+                    if (twinkling && twinkleRgb) {
+                        colorLine = twinkleRgb;
+                        opacity = (0, engine_1.getRangeValue)(twinkle.opacity);
+                    }
+                }
+                if (!colorLine) {
+                    const linksOptions = p1.options.links, linkColor = (linksOptions === null || linksOptions === void 0 ? void 0 : linksOptions.id) !== undefined
+                        ? container.particles.linksColors.get(linksOptions.id)
+                        : container.particles.linksColor;
+                    colorLine = (0, engine_1.getLinkColor)(p1, p2, linkColor);
+                }
+                if (!colorLine) {
+                    return;
+                }
+                const width = (_b = p1.retina.linksWidth) !== null && _b !== void 0 ? _b : 0, maxDistance = (_c = p1.retina.linksDistance) !== null && _c !== void 0 ? _c : 0;
+                (0, Utils_1.drawLinkLine)(ctx, width, pos1, pos2, maxDistance, container.canvas.size, p1.options.links.warp, options.backgroundMask.enable, options.backgroundMask.composite, colorLine, opacity, p1.options.links.shadow);
+            });
+        }
+        drawLinkTriangle(p1, link1, link2) {
+            var _a;
+            if (!p1.options.links) {
+                return;
+            }
+            const container = this.container, options = container.actualOptions, p2 = link1.destination, p3 = link2.destination, triangleOptions = p1.options.links.triangles, opacityTriangle = (_a = triangleOptions.opacity) !== null && _a !== void 0 ? _a : (link1.opacity + link2.opacity) / 2;
+            if (opacityTriangle <= 0) {
+                return;
+            }
+            container.canvas.draw((ctx) => {
+                var _a;
+                const pos1 = p1.getPosition(), pos2 = p2.getPosition(), pos3 = p3.getPosition(), linksDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : 0;
+                if ((0, engine_1.getDistance)(pos1, pos2) > linksDistance ||
+                    (0, engine_1.getDistance)(pos3, pos2) > linksDistance ||
+                    (0, engine_1.getDistance)(pos3, pos1) > linksDistance) {
+                    return;
+                }
+                let colorTriangle = (0, engine_1.rangeColorToRgb)(triangleOptions.color);
+                if (!colorTriangle) {
+                    const linksOptions = p1.options.links, linkColor = (linksOptions === null || linksOptions === void 0 ? void 0 : linksOptions.id) !== undefined
+                        ? container.particles.linksColors.get(linksOptions.id)
+                        : container.particles.linksColor;
+                    colorTriangle = (0, engine_1.getLinkColor)(p1, p2, linkColor);
+                }
+                if (!colorTriangle) {
+                    return;
+                }
+                (0, Utils_1.drawLinkTriangle)(ctx, pos1, pos2, pos3, options.backgroundMask.enable, options.backgroundMask.composite, colorTriangle, opacityTriangle);
+            });
+        }
+        drawTriangles(options, p1, link, p1Links) {
+            var _a, _b, _c;
+            const p2 = link.destination;
+            if (!(((_a = options.links) === null || _a === void 0 ? void 0 : _a.triangles.enable) && ((_b = p2.options.links) === null || _b === void 0 ? void 0 : _b.triangles.enable))) {
+                return;
+            }
+            const vertices = (_c = p2.links) === null || _c === void 0 ? void 0 : _c.filter((t) => {
+                const linkFreq = this.getLinkFrequency(p2, t.destination);
+                return (p2.options.links &&
+                    linkFreq <= p2.options.links.frequency &&
+                    p1Links.findIndex((l) => l.destination === t.destination) >= 0);
+            });
+            if (!(vertices === null || vertices === void 0 ? void 0 : vertices.length)) {
+                return;
+            }
+            for (const vertex of vertices) {
+                const p3 = vertex.destination, triangleFreq = this.getTriangleFrequency(p1, p2, p3);
+                if (triangleFreq > options.links.triangles.frequency) {
+                    continue;
+                }
+                this.drawLinkTriangle(p1, link, vertex);
+            }
+        }
+        getLinkFrequency(p1, p2) {
+            return setLinkFrequency([p1, p2], this._freqs.links);
+        }
+        getTriangleFrequency(p1, p2, p3) {
+            return setLinkFrequency([p1, p2, p3], this._freqs.triangles);
+        }
+    }
+    exports.LinkInstance = LinkInstance;
+});

package/umd/LinkParticle.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/Linker.js

@@ -0,0 +1,133 @@
+(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", "./CircleWarp", "./Options/Classes/Links"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Linker = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const CircleWarp_1 = require("./CircleWarp");
+    const Links_1 = require("./Options/Classes/Links");
+    function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
+        let distance = (0, engine_1.getDistance)(pos1, pos2);
+        if (!warp || distance <= optDistance) {
+            return distance;
+        }
+        const pos2NE = {
+            x: pos2.x - canvasSize.width,
+            y: pos2.y,
+        };
+        distance = (0, engine_1.getDistance)(pos1, pos2NE);
+        if (distance <= optDistance) {
+            return distance;
+        }
+        const pos2SE = {
+            x: pos2.x - canvasSize.width,
+            y: pos2.y - canvasSize.height,
+        };
+        distance = (0, engine_1.getDistance)(pos1, pos2SE);
+        if (distance <= optDistance) {
+            return distance;
+        }
+        const pos2SW = {
+            x: pos2.x,
+            y: pos2.y - canvasSize.height,
+        };
+        distance = (0, engine_1.getDistance)(pos1, pos2SW);
+        return distance;
+    }
+    class Linker extends engine_1.ParticlesInteractorBase {
+        constructor(container) {
+            super(container);
+            this.linkContainer = container;
+        }
+        clear() {
+        }
+        init() {
+            this.linkContainer.particles.linksColor = undefined;
+            this.linkContainer.particles.linksColors = new Map();
+        }
+        async interact(p1) {
+            var _a;
+            if (!p1.options.links) {
+                return;
+            }
+            p1.links = [];
+            const pos1 = p1.getPosition(), container = this.container, canvasSize = container.canvas.size;
+            if (pos1.x < 0 || pos1.y < 0 || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
+                return;
+            }
+            const linkOpt1 = p1.options.links, optOpacity = linkOpt1.opacity, optDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : 0, warp = linkOpt1.warp, range = warp
+                ? new CircleWarp_1.CircleWarp(pos1.x, pos1.y, optDistance, canvasSize)
+                : new engine_1.Circle(pos1.x, pos1.y, optDistance), query = container.particles.quadTree.query(range);
+            for (const p2 of query) {
+                const linkOpt2 = p2.options.links;
+                if (p1 === p2 ||
+                    !(linkOpt2 === null || linkOpt2 === void 0 ? void 0 : linkOpt2.enable) ||
+                    linkOpt1.id !== linkOpt2.id ||
+                    p2.spawning ||
+                    p2.destroyed ||
+                    !p2.links ||
+                    p1.links.map((t) => t.destination).indexOf(p2) !== -1 ||
+                    p2.links.map((t) => t.destination).indexOf(p1) !== -1) {
+                    continue;
+                }
+                const pos2 = p2.getPosition();
+                if (pos2.x < 0 || pos2.y < 0 || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
+                    continue;
+                }
+                const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
+                if (distance > optDistance) {
+                    return;
+                }
+                const opacityLine = (1 - distance / optDistance) * optOpacity;
+                this.setColor(p1);
+                p1.links.push({
+                    destination: p2,
+                    opacity: opacityLine,
+                });
+            }
+        }
+        isEnabled(particle) {
+            var _a;
+            return !!((_a = particle.options.links) === null || _a === void 0 ? void 0 : _a.enable);
+        }
+        loadParticlesOptions(options, ...sources) {
+            var _a, _b;
+            if (!options.links) {
+                options.links = new Links_1.Links();
+            }
+            for (const source of sources) {
+                options.links.load((_b = (_a = source === null || source === void 0 ? void 0 : source.links) !== null && _a !== void 0 ? _a : source === null || source === void 0 ? void 0 : source.lineLinked) !== null && _b !== void 0 ? _b : source === null || source === void 0 ? void 0 : source.line_linked);
+            }
+        }
+        reset() {
+        }
+        setColor(p1) {
+            if (!p1.options.links) {
+                return;
+            }
+            const container = this.linkContainer, linksOptions = p1.options.links;
+            let linkColor = linksOptions.id === undefined
+                ? container.particles.linksColor
+                : container.particles.linksColors.get(linksOptions.id);
+            if (linkColor) {
+                return;
+            }
+            const optColor = linksOptions.color;
+            linkColor = (0, engine_1.getLinkRandomColor)(optColor, linksOptions.blink, linksOptions.consent);
+            if (linksOptions.id === undefined) {
+                container.particles.linksColor = linkColor;
+            }
+            else {
+                container.particles.linksColors.set(linksOptions.id, linkColor);
+            }
+        }
+    }
+    exports.Linker = Linker;
+});

package/umd/Options/Classes/Links.js

@@ -0,0 +1,68 @@
+(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", "./LinksShadow", "./LinksTriangle", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Links = void 0;
+    const LinksShadow_1 = require("./LinksShadow");
+    const LinksTriangle_1 = require("./LinksTriangle");
+    const engine_1 = require("@tsparticles/engine");
+    class Links {
+        constructor() {
+            this.blink = false;
+            this.color = new engine_1.OptionsColor();
+            this.color.value = "#fff";
+            this.consent = false;
+            this.distance = 100;
+            this.enable = false;
+            this.frequency = 1;
+            this.opacity = 1;
+            this.shadow = new LinksShadow_1.LinksShadow();
+            this.triangles = new LinksTriangle_1.LinksTriangle();
+            this.width = 1;
+            this.warp = false;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.id !== undefined) {
+                this.id = data.id;
+            }
+            if (data.blink !== undefined) {
+                this.blink = data.blink;
+            }
+            this.color = engine_1.OptionsColor.create(this.color, data.color);
+            if (data.consent !== undefined) {
+                this.consent = data.consent;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.frequency !== undefined) {
+                this.frequency = data.frequency;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+            this.shadow.load(data.shadow);
+            this.triangles.load(data.triangles);
+            if (data.width !== undefined) {
+                this.width = data.width;
+            }
+            if (data.warp !== undefined) {
+                this.warp = data.warp;
+            }
+        }
+    }
+    exports.Links = Links;
+});