dune-react 0.0.1

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Particles.js

@@ -0,0 +1,326 @@
+import { minLimit, defaultDensityFactor, squareExp, errorPrefix, deleteCount, qTreeCapacity, minCount, defaultRemoveQuantity, minIndex, lengthOffset, countOffset, posOffset, sizeFactor } from "./Utils/Constants.js";
+import { getLogger, getPosition } from "../Utils/Utils.js";
+import { EventType } from "../Enums/Types/EventType.js";
+import { InteractionManager } from "./Utils/InteractionManager.js";
+import { LimitMode } from "../Enums/Modes/LimitMode.js";
+import { Particle } from "./Particle.js";
+import { Point } from "./Utils/Point.js";
+import { QuadTree } from "./Utils/QuadTree.js";
+import { Rectangle } from "./Utils/Ranges.js";
+const qTreeRectangle = (canvasSize) => {
+  const { height, width } = canvasSize;
+  return new Rectangle(posOffset * width, posOffset * height, sizeFactor * width, sizeFactor * height);
+};
+class Particles {
+  constructor(engine, container) {
+    this._addToPool = (...particles) => {
+      this._pool.push(...particles);
+    };
+    this._applyDensity = (options, manualCount, group, groupOptions) => {
+      var _a, _b, _c;
+      const numberOptions = options.number;
+      if (!((_a = options.number.density) == null ? void 0 : _a.enable)) {
+        if (group === void 0) {
+          this._limit = numberOptions.limit.value;
+        } else if (((_b = groupOptions == null ? void 0 : groupOptions.number.limit) == null ? void 0 : _b.value) ?? numberOptions.limit.value) {
+          this._groupLimits.set(group, ((_c = groupOptions == null ? void 0 : groupOptions.number.limit) == null ? void 0 : _c.value) ?? numberOptions.limit.value);
+        }
+        return;
+      }
+      const densityFactor = this._initDensityFactor(numberOptions.density), optParticlesNumber = numberOptions.value, optParticlesLimit = numberOptions.limit.value > minLimit ? numberOptions.limit.value : optParticlesNumber, particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount, particlesCount = Math.min(this.count, this.filter((t) => t.group === group).length);
+      if (group === void 0) {
+        this._limit = numberOptions.limit.value * densityFactor;
+      } else {
+        this._groupLimits.set(group, numberOptions.limit.value * densityFactor);
+      }
+      if (particlesCount < particlesNumber) {
+        this.push(Math.abs(particlesNumber - particlesCount), void 0, options, group);
+      } else if (particlesCount > particlesNumber) {
+        this.removeQuantity(particlesCount - particlesNumber, group);
+      }
+    };
+    this._initDensityFactor = (densityOptions) => {
+      const container2 = this._container;
+      if (!container2.canvas.element || !densityOptions.enable) {
+        return defaultDensityFactor;
+      }
+      const canvas = container2.canvas.element, pxRatio = container2.retina.pixelRatio;
+      return canvas.width * canvas.height / (densityOptions.height * densityOptions.width * pxRatio ** squareExp);
+    };
+    this._pushParticle = (position, overrideOptions, group, initializer) => {
+      try {
+        let particle = this._pool.pop();
+        if (!particle) {
+          particle = new Particle(this._engine, this._container);
+        }
+        particle.init(this._nextId, position, overrideOptions, group);
+        let canAdd = true;
+        if (initializer) {
+          canAdd = initializer(particle);
+        }
+        if (!canAdd) {
+          return;
+        }
+        this._array.push(particle);
+        this._zArray.push(particle);
+        this._nextId++;
+        this._engine.dispatchEvent(EventType.particleAdded, {
+          container: this._container,
+          data: {
+            particle
+          }
+        });
+        return particle;
+      } catch (e) {
+        getLogger().warning(`${errorPrefix} adding particle: ${e}`);
+      }
+    };
+    this._removeParticle = (index, group, override) => {
+      const particle = this._array[index];
+      if (!particle || particle.group !== group) {
+        return false;
+      }
+      const zIdx = this._zArray.indexOf(particle);
+      this._array.splice(index, deleteCount);
+      this._zArray.splice(zIdx, deleteCount);
+      particle.destroy(override);
+      this._engine.dispatchEvent(EventType.particleRemoved, {
+        container: this._container,
+        data: {
+          particle
+        }
+      });
+      this._addToPool(particle);
+      return true;
+    };
+    this._engine = engine;
+    this._container = container;
+    this._nextId = 0;
+    this._array = [];
+    this._zArray = [];
+    this._pool = [];
+    this._limit = 0;
+    this._groupLimits = /* @__PURE__ */ new Map();
+    this._needsSort = false;
+    this._lastZIndex = 0;
+    this._interactionManager = new InteractionManager(engine, container);
+    this._pluginsInitialized = false;
+    const canvasSize = container.canvas.size;
+    this.quadTree = new QuadTree(qTreeRectangle(canvasSize), qTreeCapacity);
+    this.movers = [];
+    this.updaters = [];
+  }
+  get count() {
+    return this._array.length;
+  }
+  addManualParticles() {
+    const container = this._container, options = container.actualOptions;
+    options.manualParticles.forEach((p) => this.addParticle(p.position ? getPosition(p.position, container.canvas.size) : void 0, p.options));
+  }
+  addParticle(position, overrideOptions, group, initializer) {
+    const limitMode = this._container.actualOptions.particles.number.limit.mode, limit = group === void 0 ? this._limit : this._groupLimits.get(group) ?? this._limit, currentCount = this.count;
+    if (limit > minLimit) {
+      switch (limitMode) {
+        case LimitMode.delete: {
+          const countToRemove = currentCount + countOffset - limit;
+          if (countToRemove > minCount) {
+            this.removeQuantity(countToRemove);
+          }
+          break;
+        }
+        case LimitMode.wait:
+          if (currentCount >= limit) {
+            return;
+          }
+          break;
+      }
+    }
+    return this._pushParticle(position, overrideOptions, group, initializer);
+  }
+  clear() {
+    this._array = [];
+    this._zArray = [];
+    this._pluginsInitialized = false;
+  }
+  destroy() {
+    this._array = [];
+    this._zArray = [];
+    this.movers = [];
+    this.updaters = [];
+  }
+  draw(delta) {
+    const container = this._container, canvas = container.canvas;
+    canvas.clear();
+    this.update(delta);
+    for (const plugin of container.plugins.values()) {
+      canvas.drawPlugin(plugin, delta);
+    }
+    for (const p of this._zArray) {
+      p.draw(delta);
+    }
+  }
+  filter(condition) {
+    return this._array.filter(condition);
+  }
+  find(condition) {
+    return this._array.find(condition);
+  }
+  get(index) {
+    return this._array[index];
+  }
+  handleClickMode(mode) {
+    this._interactionManager.handleClickMode(mode);
+  }
+  async init() {
+    var _a, _b;
+    const container = this._container, options = container.actualOptions;
+    this._lastZIndex = 0;
+    this._needsSort = false;
+    await this.initPlugins();
+    let handled = false;
+    for (const plugin of container.plugins.values()) {
+      handled = ((_a = plugin.particlesInitialization) == null ? void 0 : _a.call(plugin)) ?? handled;
+      if (handled) {
+        break;
+      }
+    }
+    this.addManualParticles();
+    if (!handled) {
+      const particlesOptions = options.particles, groups = particlesOptions.groups;
+      for (const group in groups) {
+        const groupOptions = groups[group];
+        for (let i = this.count, j = 0; j < ((_b = groupOptions.number) == null ? void 0 : _b.value) && i < particlesOptions.number.value; i++, j++) {
+          this.addParticle(void 0, groupOptions, group);
+        }
+      }
+      for (let i = this.count; i < particlesOptions.number.value; i++) {
+        this.addParticle();
+      }
+    }
+  }
+  async initPlugins() {
+    if (this._pluginsInitialized) {
+      return;
+    }
+    const container = this._container;
+    this.movers = await this._engine.getMovers(container, true);
+    this.updaters = await this._engine.getUpdaters(container, true);
+    await this._interactionManager.init();
+    for (const pathGenerator of container.pathGenerators.values()) {
+      pathGenerator.init(container);
+    }
+  }
+  push(nb, mouse, overrideOptions, group) {
+    for (let i = 0; i < nb; i++) {
+      this.addParticle(mouse == null ? void 0 : mouse.position, overrideOptions, group);
+    }
+  }
+  async redraw() {
+    this.clear();
+    await this.init();
+    this.draw({ value: 0, factor: 0 });
+  }
+  remove(particle, group, override) {
+    this.removeAt(this._array.indexOf(particle), void 0, group, override);
+  }
+  removeAt(index, quantity = defaultRemoveQuantity, group, override) {
+    if (index < minIndex || index > this.count) {
+      return;
+    }
+    let deleted = 0;
+    for (let i = index; deleted < quantity && i < this.count; i++) {
+      if (this._removeParticle(i, group, override)) {
+        i--;
+        deleted++;
+      }
+    }
+  }
+  removeQuantity(quantity, group) {
+    this.removeAt(minIndex, quantity, group);
+  }
+  setDensity() {
+    const options = this._container.actualOptions, groups = options.particles.groups, manualCount = options.manualParticles.length;
+    for (const group in groups) {
+      this._applyDensity(groups[group], manualCount, group);
+    }
+    this._applyDensity(options.particles, manualCount);
+  }
+  setLastZIndex(zIndex) {
+    this._lastZIndex = zIndex;
+    this._needsSort = this._needsSort || this._lastZIndex < zIndex;
+  }
+  setResizeFactor(factor) {
+    this._resizeFactor = factor;
+  }
+  update(delta) {
+    var _a, _b;
+    const container = this._container, particlesToDelete = /* @__PURE__ */ new Set();
+    this.quadTree = new QuadTree(qTreeRectangle(container.canvas.size), qTreeCapacity);
+    for (const pathGenerator of container.pathGenerators.values()) {
+      pathGenerator.update();
+    }
+    for (const plugin of container.plugins.values()) {
+      (_a = plugin.update) == null ? void 0 : _a.call(plugin, delta);
+    }
+    const resizeFactor = this._resizeFactor;
+    for (const particle of this._array) {
+      if (resizeFactor && !particle.ignoresResizeRatio) {
+        particle.position.x *= resizeFactor.width;
+        particle.position.y *= resizeFactor.height;
+        particle.initialPosition.x *= resizeFactor.width;
+        particle.initialPosition.y *= resizeFactor.height;
+      }
+      particle.ignoresResizeRatio = false;
+      this._interactionManager.reset(particle);
+      for (const plugin of this._container.plugins.values()) {
+        if (particle.destroyed) {
+          break;
+        }
+        (_b = plugin.particleUpdate) == null ? void 0 : _b.call(plugin, particle, delta);
+      }
+      for (const mover of this.movers) {
+        if (mover.isEnabled(particle)) {
+          mover.move(particle, delta);
+        }
+      }
+      if (particle.destroyed) {
+        particlesToDelete.add(particle);
+        continue;
+      }
+      this.quadTree.insert(new Point(particle.getPosition(), particle));
+    }
+    if (particlesToDelete.size) {
+      const checkDelete = (p) => !particlesToDelete.has(p);
+      this._array = this.filter(checkDelete);
+      this._zArray = this._zArray.filter(checkDelete);
+      for (const particle of particlesToDelete) {
+        this._engine.dispatchEvent(EventType.particleRemoved, {
+          container: this._container,
+          data: {
+            particle
+          }
+        });
+      }
+      this._addToPool(...particlesToDelete);
+    }
+    this._interactionManager.externalInteract(delta);
+    for (const particle of this._array) {
+      for (const updater of this.updaters) {
+        updater.update(particle, delta);
+      }
+      if (!particle.destroyed && !particle.spawning) {
+        this._interactionManager.particlesInteract(particle, delta);
+      }
+    }
+    delete this._resizeFactor;
+    if (this._needsSort) {
+      const zArray = this._zArray;
+      zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
+      this._lastZIndex = zArray[zArray.length - lengthOffset].position.z;
+      this._needsSort = false;
+    }
+  }
+}
+export {
+  Particles
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Retina.js

@@ -0,0 +1,37 @@
+import { defaultRatio, defaultReduceFactor } from "./Utils/Constants.js";
+import { getRangeValue } from "../Utils/NumberUtils.js";
+import { isSsr } from "../Utils/Utils.js";
+class Retina {
+  constructor(container) {
+    this.container = container;
+    this.pixelRatio = defaultRatio;
+    this.reduceFactor = defaultReduceFactor;
+  }
+  init() {
+    const container = this.container, options = container.actualOptions;
+    this.pixelRatio = !options.detectRetina || isSsr() ? defaultRatio : devicePixelRatio;
+    this.reduceFactor = defaultReduceFactor;
+    const ratio = this.pixelRatio, canvas = container.canvas;
+    if (canvas.element) {
+      const element = canvas.element;
+      canvas.size.width = element.offsetWidth * ratio;
+      canvas.size.height = element.offsetHeight * ratio;
+    }
+    const particles = options.particles, moveOptions = particles.move;
+    this.maxSpeed = getRangeValue(moveOptions.gravity.maxSpeed) * ratio;
+    this.sizeAnimationSpeed = getRangeValue(particles.size.animation.speed) * ratio;
+  }
+  initParticle(particle) {
+    const options = particle.options, ratio = this.pixelRatio, moveOptions = options.move, moveDistance = moveOptions.distance, props = particle.retina;
+    props.moveDrift = getRangeValue(moveOptions.drift) * ratio;
+    props.moveSpeed = getRangeValue(moveOptions.speed) * ratio;
+    props.sizeAnimationSpeed = getRangeValue(options.size.animation.speed) * ratio;
+    const maxDistance = props.maxDistance;
+    maxDistance.horizontal = moveDistance.horizontal !== void 0 ? moveDistance.horizontal * ratio : void 0;
+    maxDistance.vertical = moveDistance.vertical !== void 0 ? moveDistance.vertical * ratio : void 0;
+    props.maxSpeed = getRangeValue(moveOptions.gravity.maxSpeed) * ratio;
+  }
+}
+export {
+  Retina
+};

package/dist/node_modules/.pnpm/@tsparticles_engine@3.9.1/node_modules/@tsparticles/engine/browser/Core/Utils/Constants.js

@@ -0,0 +1,105 @@
+const generatedAttribute = "generated", mouseDownEvent = "pointerdown", mouseUpEvent = "pointerup", mouseLeaveEvent = "pointerleave", mouseOutEvent = "pointerout", mouseMoveEvent = "pointermove", touchStartEvent = "touchstart", touchEndEvent = "touchend", touchMoveEvent = "touchmove", touchCancelEvent = "touchcancel", resizeEvent = "resize", visibilityChangeEvent = "visibilitychange", errorPrefix = "tsParticles - Error", percentDenominator = 100, half = 0.5, millisecondsToSeconds = 1e3, originPoint = {
+  x: 0,
+  y: 0,
+  z: 0
+}, defaultTransform = {
+  a: 1,
+  b: 0,
+  c: 0,
+  d: 1
+}, randomColorValue = "random", midColorValue = "mid", double = 2, doublePI = Math.PI * double, defaultFps = 60, generatedTrue = "true", generatedFalse = "false", canvasTag = "canvas", defaultRetryCount = 0, squareExp = 2, qTreeCapacity = 4, defaultRemoveQuantity = 1, defaultRatio = 1, defaultReduceFactor = 1, subdivideCount = 4, inverseFactorNumerator = 1, rgbMax = 255, hMax = 360, sMax = 100, lMax = 100, hMin = 0, sMin = 0, hPhase = 60, empty = 0, quarter = 0.25, threeQuarter = half + quarter, minVelocity = 0, defaultTransformValue = 1, minimumSize = 0, minimumLength = 0, zIndexFactorOffset = 1, defaultOpacity = 1, clickRadius = 1, touchEndLengthOffset = 1, minCoordinate = 0, removeDeleteCount = 1, removeMinIndex = 0, defaultFpsLimit = 120, minFpsLimit = 0, canvasFirstIndex = 0, loadRandomFactor = 1e4, loadMinIndex = 0, one = 1, none = 0, decayOffset = 1, tryCountIncrement = 1, minRetries = 0, rollFactor = 1, minZ = 0, defaultRadius = 0, posOffset = -quarter, sizeFactor = 1.5, minLimit = 0, countOffset = 1, minCount = 0, minIndex = 0, lengthOffset = 1, defaultDensityFactor = 1, deleteCount = 1, touchDelay = 500, manualDefaultPosition = 50, defaultAngle = 0, identity = 1, minStrokeWidth = 0, lFactor = 1, lMin = 0, rgbFactor = 255, triple = 3, sextuple = 6, sNormalizedOffset = 1, phaseNumerator = 1, defaultRgbMin = 0, defaultVelocity = 0, defaultLoops = 0, defaultTime = 0;
+export {
+  canvasFirstIndex,
+  canvasTag,
+  clickRadius,
+  countOffset,
+  decayOffset,
+  defaultAngle,
+  defaultDensityFactor,
+  defaultFps,
+  defaultFpsLimit,
+  defaultLoops,
+  defaultOpacity,
+  defaultRadius,
+  defaultRatio,
+  defaultReduceFactor,
+  defaultRemoveQuantity,
+  defaultRetryCount,
+  defaultRgbMin,
+  defaultTime,
+  defaultTransform,
+  defaultTransformValue,
+  defaultVelocity,
+  deleteCount,
+  double,
+  doublePI,
+  empty,
+  errorPrefix,
+  generatedAttribute,
+  generatedFalse,
+  generatedTrue,
+  hMax,
+  hMin,
+  hPhase,
+  half,
+  identity,
+  inverseFactorNumerator,
+  lFactor,
+  lMax,
+  lMin,
+  lengthOffset,
+  loadMinIndex,
+  loadRandomFactor,
+  manualDefaultPosition,
+  midColorValue,
+  millisecondsToSeconds,
+  minCoordinate,
+  minCount,
+  minFpsLimit,
+  minIndex,
+  minLimit,
+  minRetries,
+  minStrokeWidth,
+  minVelocity,
+  minZ,
+  minimumLength,
+  minimumSize,
+  mouseDownEvent,
+  mouseLeaveEvent,
+  mouseMoveEvent,
+  mouseOutEvent,
+  mouseUpEvent,
+  none,
+  one,
+  originPoint,
+  percentDenominator,
+  phaseNumerator,
+  posOffset,
+  qTreeCapacity,
+  quarter,
+  randomColorValue,
+  removeDeleteCount,
+  removeMinIndex,
+  resizeEvent,
+  rgbFactor,
+  rgbMax,
+  rollFactor,
+  sMax,
+  sMin,
+  sNormalizedOffset,
+  sextuple,
+  sizeFactor,
+  squareExp,
+  subdivideCount,
+  threeQuarter,
+  touchCancelEvent,
+  touchDelay,
+  touchEndEvent,
+  touchEndLengthOffset,
+  touchMoveEvent,
+  touchStartEvent,
+  triple,
+  tryCountIncrement,
+  visibilityChangeEvent,
+  zIndexFactorOffset
+};