@tsparticles/stencil 4.0.5

package/dist/cjs/index.cjs.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var index = require('./index-BY5-j3YK.js');
+
+
+
+exports.initParticlesEngine = index.initParticlesEngine;
+exports.isParticlesEngineInitialized = index.isParticlesEngineInitialized;
+exports.waitForParticlesEngineInitialization = index.waitForParticlesEngineInitialization;

package/dist/cjs/loader.cjs.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('./index-Dwz1YgEM.js');
+var appGlobals = require('./app-globals-V2Kpy_OQ.js');
+
+const defineCustomElements = async (win, options) => {
+  if (typeof window === 'undefined') return undefined;
+  await appGlobals.globalScripts();
+  return index.bootstrapLazy([["stencil-particles.cjs",[[0,"stencil-particles",{"options":[16],"url":[1],"init":[16]},null,{"options":[{"onPropsChange":0}],"url":[{"onPropsChange":0}],"init":[{"onPropsChange":0}]}]]]], options);
+};
+
+exports.setNonce = index.setNonce;
+exports.defineCustomElements = defineCustomElements;

package/dist/cjs/stencil-particles.cjs.entry.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var index = require('./index-Dwz1YgEM.js');
+var index$1 = require('./index-BY5-j3YK.js');
+
+const StencilParticles = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.renderId = 0;
+    }
+    async componentDidLoad() {
+        await this.loadParticles(++this.renderId);
+    }
+    disconnectedCallback() {
+        var _a;
+        this.renderId++; // Invalidate any pending load promises
+        (_a = this.container) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.container = undefined;
+    }
+    async onPropsChange() {
+        await this.loadParticles(++this.renderId);
+    }
+    async loadParticles(currentRenderId) {
+        var _a;
+        (_a = this.container) === null || _a === void 0 ? void 0 : _a.destroy();
+        if (!this.containerElement) {
+            console.warn("[stencil-particles] container element not available yet");
+            return;
+        }
+        let container;
+        try {
+            // Use the shared initialization logic to ensure consistent plugin registration
+            // and avoid duplicate initialization when multiple instances mount concurrently.
+            // initParticlesEngine handles promise de-duplication and enforces a stable init callback.
+            if (this.init) {
+                await index$1.initParticlesEngine(this.init);
+            }
+            if (!this.options && !this.url) {
+                console.warn("[stencil-particles] neither options nor url provided");
+                return;
+            }
+            // Load particles directly onto the DOM element.
+            // tsParticles will auto-generate a unique internal ID, preventing collisions.
+            const loadParams = Object.assign({ element: this.containerElement }, (this.options ? { options: this.options } : { url: this.url }));
+            container = await index$1.tsParticles.load(loadParams);
+        }
+        catch (error) {
+            console.error("[stencil-particles] load failed", error);
+            return;
+        }
+        // Race condition guard: discard result if props changed during async load
+        if (currentRenderId !== this.renderId) {
+            container === null || container === void 0 ? void 0 : container.destroy();
+            return;
+        }
+        this.container = container;
+    }
+    render() {
+        return (index.h("div", { key: '870e2cc222aed94f8bbfa274dc3c047392ed8b1a', ref: el => {
+                this.containerElement = el;
+            }, style: { width: "100%", height: "100%" } }));
+    }
+    static get watchers() { return {
+        "options": [{
+                "onPropsChange": 0
+            }],
+        "url": [{
+                "onPropsChange": 0
+            }],
+        "init": [{
+                "onPropsChange": 0
+            }]
+    }; }
+};
+
+exports.stencil_particles = StencilParticles;

package/dist/cjs/tsparticlesstencil.cjs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var index = require('./index-Dwz1YgEM.js');
+var appGlobals = require('./app-globals-V2Kpy_OQ.js');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/*
+ Stencil Client Patch Browser v4.43.4 | MIT Licensed | https://stenciljs.com
+ */
+
+var patchBrowser = () => {
+  const importMeta = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('tsparticlesstencil.cjs.js', document.baseURI).href));
+  const opts = {};
+  if (importMeta !== "") {
+    opts.resourcesUrl = new URL(".", importMeta).href;
+  }
+  return index.promiseResolve(opts);
+};
+
+patchBrowser().then(async (options) => {
+  await appGlobals.globalScripts();
+  return index.bootstrapLazy([["stencil-particles.cjs",[[0,"stencil-particles",{"options":[16],"url":[1],"init":[16]},null,{"options":[{"onPropsChange":0}],"url":[{"onPropsChange":0}],"init":[{"onPropsChange":0}]}]]]], options);
+});
+
+exports.setNonce = index.setNonce;

package/dist/collection/collection-manifest.json

@@ -0,0 +1,13 @@
+{
+  "entries": [
+    "components/stencil-particles/stencil-particles.js"
+  ],
+  "mixins": [],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "4.43.4",
+    "typescriptVersion": "5.8.3"
+  },
+  "collections": [],
+  "bundles": []
+}

package/dist/collection/components/stencil-particles/stencil-particles.js

@@ -0,0 +1,144 @@
+import { h } from "@stencil/core";
+import { tsParticles } from "@tsparticles/engine";
+import { initParticlesEngine } from "../../initParticlesEngine";
+export class StencilParticles {
+    constructor() {
+        this.renderId = 0;
+    }
+    async componentDidLoad() {
+        await this.loadParticles(++this.renderId);
+    }
+    disconnectedCallback() {
+        var _a;
+        this.renderId++; // Invalidate any pending load promises
+        (_a = this.container) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.container = undefined;
+    }
+    async onPropsChange() {
+        await this.loadParticles(++this.renderId);
+    }
+    async loadParticles(currentRenderId) {
+        var _a;
+        (_a = this.container) === null || _a === void 0 ? void 0 : _a.destroy();
+        if (!this.containerElement) {
+            console.warn("[stencil-particles] container element not available yet");
+            return;
+        }
+        let container;
+        try {
+            // Use the shared initialization logic to ensure consistent plugin registration
+            // and avoid duplicate initialization when multiple instances mount concurrently.
+            // initParticlesEngine handles promise de-duplication and enforces a stable init callback.
+            if (this.init) {
+                await initParticlesEngine(this.init);
+            }
+            if (!this.options && !this.url) {
+                console.warn("[stencil-particles] neither options nor url provided");
+                return;
+            }
+            // Load particles directly onto the DOM element.
+            // tsParticles will auto-generate a unique internal ID, preventing collisions.
+            const loadParams = Object.assign({ element: this.containerElement }, (this.options ? { options: this.options } : { url: this.url }));
+            container = await tsParticles.load(loadParams);
+        }
+        catch (error) {
+            console.error("[stencil-particles] load failed", error);
+            return;
+        }
+        // Race condition guard: discard result if props changed during async load
+        if (currentRenderId !== this.renderId) {
+            container === null || container === void 0 ? void 0 : container.destroy();
+            return;
+        }
+        this.container = container;
+    }
+    render() {
+        return (h("div", { key: '870e2cc222aed94f8bbfa274dc3c047392ed8b1a', ref: el => {
+                this.containerElement = el;
+            }, style: { width: "100%", height: "100%" } }));
+    }
+    static get is() { return "stencil-particles"; }
+    static get properties() {
+        return {
+            "options": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ISourceOptions",
+                    "resolved": "IOptions",
+                    "references": {
+                        "ISourceOptions": {
+                            "location": "import",
+                            "path": "@tsparticles/engine",
+                            "id": "../../engine/dist/types/index.d.ts::ISourceOptions",
+                            "referenceLocation": "ISourceOptions"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "url": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "url"
+            },
+            "init": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ParticlesPluginRegistrar",
+                    "resolved": "(engine: Engine) => void | Promise<void>",
+                    "references": {
+                        "ParticlesPluginRegistrar": {
+                            "location": "import",
+                            "path": "../../initParticlesEngine",
+                            "id": "src/initParticlesEngine.ts::ParticlesPluginRegistrar",
+                            "referenceLocation": "ParticlesPluginRegistrar"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get watchers() {
+        return [{
+                "propName": "options",
+                "methodName": "onPropsChange"
+            }, {
+                "propName": "url",
+                "methodName": "onPropsChange"
+            }, {
+                "propName": "init",
+                "methodName": "onPropsChange"
+            }];
+    }
+}

package/dist/collection/index.js

@@ -0,0 +1 @@
+export { initParticlesEngine, isParticlesEngineInitialized, waitForParticlesEngineInitialization } from "./initParticlesEngine";

package/dist/collection/initParticlesEngine.js

@@ -0,0 +1,38 @@
+import { tsParticles } from "@tsparticles/engine";
+let initialized = false;
+let initPromise;
+let initCallback;
+export async function initParticlesEngine(init) {
+    if (initialized) {
+        return;
+    }
+    if (initPromise) {
+        if (initCallback !== init) {
+            throw new Error("initParticlesEngine callback must be stable across the app lifecycle.");
+        }
+        await initPromise;
+        return;
+    }
+    initCallback = init;
+    initPromise = (async () => {
+        if (init) {
+            await init(tsParticles);
+        }
+        if (typeof tsParticles.init === "function") {
+            await tsParticles.init();
+        }
+        initialized = true;
+    })().catch((error) => {
+        initPromise = undefined;
+        initCallback = undefined;
+        initialized = false;
+        throw error;
+    });
+    await initPromise;
+}
+export function isParticlesEngineInitialized() {
+    return initialized;
+}
+export async function waitForParticlesEngineInitialization() {
+    await (initPromise !== null && initPromise !== void 0 ? initPromise : Promise.resolve());
+}