@tsparticles/shape-cards 3.0.0-alpha.0

package/tsparticles.shape.cards.js

@@ -0,0 +1,350 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadCardsShape": () => (/* binding */ loadCardsShape)
+});
+
+;// CONCATENATED MODULE: ./dist/browser/Utils.js
+function drawPath(ctx, radius, path) {
+  if (!path.segments.length || !path.segments[0].values.length) {
+    return;
+  }
+  ctx.moveTo(path.segments[0].values[0].x * radius, path.segments[0].values[0].y * radius);
+  for (let i = 0; i < path.segments.length; i++) {
+    const segment = path.segments[i];
+    ctx.bezierCurveTo(segment.values[1].x * radius, segment.values[1].y * radius, segment.values[2].x * radius, segment.values[2].y * radius, segment.values[3].x * radius, segment.values[3].y * radius);
+  }
+  for (let i = path.segments.length - 1; i >= 0; i--) {
+    const segment = path.segments[i];
+    ctx.bezierCurveTo(-segment.values[2].x * radius, segment.values[2].y * radius, -segment.values[1].x * radius, segment.values[1].y * radius, -segment.values[0].x * radius, segment.values[0].y * radius);
+  }
+}
+const n = 1.0 / 2;
+const paths = {
+  heart: {
+    segments: [{
+      values: [{
+        x: 0,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }, {
+        x: n,
+        y: 0
+      }, {
+        x: n,
+        y: -n / 2
+      }]
+    }, {
+      values: [{
+        x: n,
+        y: -n / 2
+      }, {
+        x: n,
+        y: -n / 2
+      }, {
+        x: n,
+        y: -n
+      }, {
+        x: n / 2,
+        y: -n
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: -n
+      }, {
+        x: n / 2,
+        y: -n
+      }, {
+        x: 0,
+        y: -n
+      }, {
+        x: 0,
+        y: -n / 2
+      }]
+    }]
+  },
+  diamond: {
+    segments: [{
+      values: [{
+        x: 0,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }, {
+        x: 3 * n / 4,
+        y: 0
+      }, {
+        x: 3 * n / 4,
+        y: 0
+      }]
+    }, {
+      values: [{
+        x: 3 * n / 4,
+        y: 0
+      }, {
+        x: 3 * n / 4,
+        y: 0
+      }, {
+        x: 0,
+        y: -n
+      }, {
+        x: 0,
+        y: -n
+      }]
+    }]
+  },
+  club: {
+    segments: [{
+      values: [{
+        x: 0,
+        y: -n
+      }, {
+        x: 0,
+        y: -n
+      }, {
+        x: n / 2,
+        y: -n
+      }, {
+        x: n / 2,
+        y: -n / 2
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: -n / 2
+      }, {
+        x: n / 2,
+        y: -n / 2
+      }, {
+        x: n,
+        y: -n / 2
+      }, {
+        x: n,
+        y: 0
+      }]
+    }, {
+      values: [{
+        x: n,
+        y: 0
+      }, {
+        x: n,
+        y: 0
+      }, {
+        x: n,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n / 2
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n / 2
+      }, {
+        x: n / 8,
+        y: n / 2
+      }, {
+        x: n / 8,
+        y: n / 8
+      }]
+    }, {
+      values: [{
+        x: n / 8,
+        y: n / 8
+      }, {
+        x: n / 8,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n
+      }, {
+        x: n / 2,
+        y: n
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: n
+      }, {
+        x: n / 2,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }]
+    }]
+  },
+  spade: {
+    segments: [{
+      values: [{
+        x: 0,
+        y: -n
+      }, {
+        x: 0,
+        y: -n
+      }, {
+        x: n,
+        y: -n / 2
+      }, {
+        x: n,
+        y: 0
+      }]
+    }, {
+      values: [{
+        x: n,
+        y: 0
+      }, {
+        x: n,
+        y: 0
+      }, {
+        x: n,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n / 2
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n / 2
+      }, {
+        x: n / 8,
+        y: n / 2
+      }, {
+        x: n / 8,
+        y: n / 8
+      }]
+    }, {
+      values: [{
+        x: n / 8,
+        y: n / 8
+      }, {
+        x: n / 8,
+        y: n / 2
+      }, {
+        x: n / 2,
+        y: n
+      }, {
+        x: n / 2,
+        y: n
+      }]
+    }, {
+      values: [{
+        x: n / 2,
+        y: n
+      }, {
+        x: n / 2,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }, {
+        x: 0,
+        y: n
+      }]
+    }]
+  }
+};
+;// CONCATENATED MODULE: ./dist/browser/CardsSuitsDrawers.js
+
+class SpadeDrawer {
+  draw(context, particle, radius) {
+    drawPath(context, radius, paths.spade);
+  }
+}
+class HeartDrawer {
+  draw(context, particle, radius) {
+    drawPath(context, radius, paths.heart);
+  }
+}
+class DiamondDrawer {
+  draw(context, particle, radius) {
+    drawPath(context, radius, paths.diamond);
+  }
+}
+class ClubDrawer {
+  draw(context, particle, radius) {
+    drawPath(context, radius, paths.club);
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+async function loadCardsShape(engine) {
+  await engine.addShape(["spade", "spades"], new SpadeDrawer());
+  await engine.addShape(["heart", "hearts"], new HeartDrawer());
+  await engine.addShape(["diamond", "diamonds"], new DiamondDrawer());
+  await engine.addShape(["club", "clubs"], new ClubDrawer());
+}
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.shape.cards.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.shape.cards.min.js.LICENSE.txt */
+!function(e,s){if("object"==typeof exports&&"object"==typeof module)module.exports=s();else if("function"==typeof define&&define.amd)define([],s);else{var y=s();for(var a in y)("object"==typeof exports?exports:e)[a]=y[a]}}(this,(()=>(()=>{"use strict";var e={d:(s,y)=>{for(var a in y)e.o(y,a)&&!e.o(s,a)&&Object.defineProperty(s,a,{enumerable:!0,get:y[a]})},o:(e,s)=>Object.prototype.hasOwnProperty.call(e,s),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},s={};function y(e,s,y){if(y.segments.length&&y.segments[0].values.length){e.moveTo(y.segments[0].values[0].x*s,y.segments[0].values[0].y*s);for(let a=0;a<y.segments.length;a++){const x=y.segments[a];e.bezierCurveTo(x.values[1].x*s,x.values[1].y*s,x.values[2].x*s,x.values[2].y*s,x.values[3].x*s,x.values[3].y*s)}for(let a=y.segments.length-1;a>=0;a--){const x=y.segments[a];e.bezierCurveTo(-x.values[2].x*s,x.values[2].y*s,-x.values[1].x*s,x.values[1].y*s,-x.values[0].x*s,x.values[0].y*s)}}}e.r(s),e.d(s,{loadCardsShape:()=>o});const a=.5,x={heart:{segments:[{values:[{x:0,y:a},{x:0,y:a},{x:a,y:0},{x:a,y:-a/2}]},{values:[{x:a,y:-a/2},{x:a,y:-a/2},{x:a,y:-a},{x:a/2,y:-a}]},{values:[{x:a/2,y:-a},{x:a/2,y:-a},{x:0,y:-a},{x:0,y:-a/2}]}]},diamond:{segments:[{values:[{x:0,y:a},{x:0,y:a},{x:.375,y:0},{x:.375,y:0}]},{values:[{x:.375,y:0},{x:.375,y:0},{x:0,y:-a},{x:0,y:-a}]}]},club:{segments:[{values:[{x:0,y:-a},{x:0,y:-a},{x:a/2,y:-a},{x:a/2,y:-a/2}]},{values:[{x:a/2,y:-a/2},{x:a/2,y:-a/2},{x:a,y:-a/2},{x:a,y:0}]},{values:[{x:a,y:0},{x:a,y:0},{x:a,y:a/2},{x:a/2,y:a/2}]},{values:[{x:a/2,y:a/2},{x:a/2,y:a/2},{x:a/8,y:a/2},{x:a/8,y:a/8}]},{values:[{x:a/8,y:a/8},{x:a/8,y:a/2},{x:a/2,y:a},{x:a/2,y:a}]},{values:[{x:a/2,y:a},{x:a/2,y:a},{x:0,y:a},{x:0,y:a}]}]},spade:{segments:[{values:[{x:0,y:-a},{x:0,y:-a},{x:a,y:-a/2},{x:a,y:0}]},{values:[{x:a,y:0},{x:a,y:0},{x:a,y:a/2},{x:a/2,y:a/2}]},{values:[{x:a/2,y:a/2},{x:a/2,y:a/2},{x:a/8,y:a/2},{x:a/8,y:a/8}]},{values:[{x:a/8,y:a/8},{x:a/8,y:a/2},{x:a/2,y:a},{x:a/2,y:a}]},{values:[{x:a/2,y:a},{x:a/2,y:a},{x:0,y:a},{x:0,y:a}]}]}};class t{draw(e,s,a){y(e,a,x.spade)}}class l{draw(e,s,a){y(e,a,x.heart)}}class n{draw(e,s,a){y(e,a,x.diamond)}}class u{draw(e,s,a){y(e,a,x.club)}}async function o(e){await e.addShape(["spade","spades"],new t),await e.addShape(["heart","hearts"],new l),await e.addShape(["diamond","diamonds"],new n),await e.addShape(["club","clubs"],new u)}return s})()));

package/tsparticles.shape.cards.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */

package/types/CardsSuitsDrawers.d.ts

@@ -0,0 +1,13 @@
+import type { IParticle, IShapeDrawer } from "@tsparticles/engine";
+export declare class SpadeDrawer implements IShapeDrawer {
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}
+export declare class HeartDrawer implements IShapeDrawer {
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}
+export declare class DiamondDrawer implements IShapeDrawer {
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}
+export declare class ClubDrawer implements IShapeDrawer {
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}

package/types/ICardsPath.d.ts

@@ -0,0 +1,13 @@
+import type { ICoordinates } from "@tsparticles/engine";
+export interface IPathSegment {
+    values: ICoordinates[];
+}
+export interface IPath {
+    segments: IPathSegment[];
+}
+export interface ICardsPath {
+    readonly club: IPath;
+    readonly diamond: IPath;
+    readonly heart: IPath;
+    readonly spade: IPath;
+}

package/types/Utils.d.ts

@@ -0,0 +1,3 @@
+import type { ICardsPath, IPath } from "./ICardsPath";
+export declare function drawPath(ctx: CanvasRenderingContext2D, radius: number, path: IPath): void;
+export declare const paths: ICardsPath;

package/types/index.d.ts

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

package/umd/CardsSuitsDrawers.js

@@ -0,0 +1,38 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ClubDrawer = exports.DiamondDrawer = exports.HeartDrawer = exports.SpadeDrawer = void 0;
+    const Utils_1 = require("./Utils");
+    class SpadeDrawer {
+        draw(context, particle, radius) {
+            (0, Utils_1.drawPath)(context, radius, Utils_1.paths.spade);
+        }
+    }
+    exports.SpadeDrawer = SpadeDrawer;
+    class HeartDrawer {
+        draw(context, particle, radius) {
+            (0, Utils_1.drawPath)(context, radius, Utils_1.paths.heart);
+        }
+    }
+    exports.HeartDrawer = HeartDrawer;
+    class DiamondDrawer {
+        draw(context, particle, radius) {
+            (0, Utils_1.drawPath)(context, radius, Utils_1.paths.diamond);
+        }
+    }
+    exports.DiamondDrawer = DiamondDrawer;
+    class ClubDrawer {
+        draw(context, particle, radius) {
+            (0, Utils_1.drawPath)(context, radius, Utils_1.paths.club);
+        }
+    }
+    exports.ClubDrawer = ClubDrawer;
+});

package/umd/ICardsPath.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/Utils.js

@@ -0,0 +1,175 @@
+(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 });
+    exports.paths = exports.drawPath = void 0;
+    function drawPath(ctx, radius, path) {
+        if (!path.segments.length || !path.segments[0].values.length) {
+            return;
+        }
+        ctx.moveTo(path.segments[0].values[0].x * radius, path.segments[0].values[0].y * radius);
+        for (let i = 0; i < path.segments.length; i++) {
+            const segment = path.segments[i];
+            ctx.bezierCurveTo(segment.values[1].x * radius, segment.values[1].y * radius, segment.values[2].x * radius, segment.values[2].y * radius, segment.values[3].x * radius, segment.values[3].y * radius);
+        }
+        for (let i = path.segments.length - 1; i >= 0; i--) {
+            const segment = path.segments[i];
+            ctx.bezierCurveTo(-segment.values[2].x * radius, segment.values[2].y * radius, -segment.values[1].x * radius, segment.values[1].y * radius, -segment.values[0].x * radius, segment.values[0].y * radius);
+        }
+    }
+    exports.drawPath = drawPath;
+    const n = 1.0 / 2;
+    exports.paths = {
+        heart: {
+            segments: [
+                {
+                    values: [
+                        { x: 0, y: n },
+                        { x: 0, y: n },
+                        { x: n, y: 0 },
+                        { x: n, y: -n / 2 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n, y: -n / 2 },
+                        { x: n, y: -n / 2 },
+                        { x: n, y: -n },
+                        { x: n / 2, y: -n },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: -n },
+                        { x: n / 2, y: -n },
+                        { x: 0, y: -n },
+                        { x: 0, y: -n / 2 },
+                    ],
+                },
+            ],
+        },
+        diamond: {
+            segments: [
+                {
+                    values: [
+                        { x: 0, y: n },
+                        { x: 0, y: n },
+                        { x: (3 * n) / 4, y: 0 },
+                        { x: (3 * n) / 4, y: 0 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: (3 * n) / 4, y: 0 },
+                        { x: (3 * n) / 4, y: 0 },
+                        { x: 0, y: -n },
+                        { x: 0, y: -n },
+                    ],
+                },
+            ],
+        },
+        club: {
+            segments: [
+                {
+                    values: [
+                        { x: 0, y: -n },
+                        { x: 0, y: -n },
+                        { x: n / 2, y: -n },
+                        { x: n / 2, y: -n / 2 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: -n / 2 },
+                        { x: n / 2, y: -n / 2 },
+                        { x: n, y: -n / 2 },
+                        { x: n, y: 0 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n, y: 0 },
+                        { x: n, y: 0 },
+                        { x: n, y: n / 2 },
+                        { x: n / 2, y: n / 2 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: n / 2 },
+                        { x: n / 2, y: n / 2 },
+                        { x: n / 8, y: n / 2 },
+                        { x: n / 8, y: n / 8 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 8, y: n / 8 },
+                        { x: n / 8, y: n / 2 },
+                        { x: n / 2, y: n },
+                        { x: n / 2, y: n },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: n },
+                        { x: n / 2, y: n },
+                        { x: 0, y: n },
+                        { x: 0, y: n },
+                    ],
+                },
+            ],
+        },
+        spade: {
+            segments: [
+                {
+                    values: [
+                        { x: 0, y: -n },
+                        { x: 0, y: -n },
+                        { x: n, y: -n / 2 },
+                        { x: n, y: 0 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n, y: 0 },
+                        { x: n, y: 0 },
+                        { x: n, y: n / 2 },
+                        { x: n / 2, y: n / 2 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: n / 2 },
+                        { x: n / 2, y: n / 2 },
+                        { x: n / 8, y: n / 2 },
+                        { x: n / 8, y: n / 8 },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 8, y: n / 8 },
+                        { x: n / 8, y: n / 2 },
+                        { x: n / 2, y: n },
+                        { x: n / 2, y: n },
+                    ],
+                },
+                {
+                    values: [
+                        { x: n / 2, y: n },
+                        { x: n / 2, y: n },
+                        { x: 0, y: n },
+                        { x: 0, y: n },
+                    ],
+                },
+            ],
+        },
+    };
+});

package/umd/index.js

@@ -0,0 +1,21 @@
+(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", "./CardsSuitsDrawers"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadCardsShape = void 0;
+    const CardsSuitsDrawers_1 = require("./CardsSuitsDrawers");
+    async function loadCardsShape(engine) {
+        await engine.addShape(["spade", "spades"], new CardsSuitsDrawers_1.SpadeDrawer());
+        await engine.addShape(["heart", "hearts"], new CardsSuitsDrawers_1.HeartDrawer());
+        await engine.addShape(["diamond", "diamonds"], new CardsSuitsDrawers_1.DiamondDrawer());
+        await engine.addShape(["club", "clubs"], new CardsSuitsDrawers_1.ClubDrawer());
+    }
+    exports.loadCardsShape = loadCardsShape;
+});