@nightshadeui/particle-system 2.15.0

package/dist/ParticleSystemController.d.ts

@@ -0,0 +1,59 @@
+import { Event } from 'nanoevent';
+import { ParticleState, ParticleSystemConfig } from './types.js';
+export declare class ParticleSystemController {
+    started: Event<void>;
+    paused: Event<void>;
+    resumed: Event<void>;
+    finished: Event<void>;
+    particles: import('vue').Reactive<ParticleState[]>;
+    config: {
+        seed: number;
+        isPaused: boolean;
+        startCount: number;
+        rateOverTime: number;
+        lifetime: import('./types.js').NumberValue;
+        shape: import('./types.js').Vector2Value;
+        size: import('./types.js').NumberValue;
+        sizeOverTime: import('./types.js').NumberValue;
+        scale: import('./types.js').Vector2Value;
+        scaleOverTime: import('./types.js').Vector2Value;
+        opacity: import('./types.js').NumberValue;
+        opacityOverTime: import('./types.js').NumberValue;
+        linearVelocity: import('./types.js').Vector2Value;
+        linearAcceleration: import('./types.js').Vector2Value;
+        radialVelocity: import('./types.js').NumberValue;
+        radialAcceleration: import('./types.js').NumberValue;
+        rotation: import('./types.js').NumberValue;
+        rotationOverTime: import('./types.js').NumberValue;
+        turbulence: import('./types.js').NumberValue;
+        noiseScale: import('./types.js').NumberValue;
+    };
+    private index;
+    private spawnAccumulator;
+    private random;
+    private noise;
+    private lastTime;
+    private frame;
+    private mounted;
+    private state;
+    constructor(config?: ParticleSystemConfig);
+    get isDrained(): boolean;
+    get isRunning(): boolean;
+    get isPaused(): boolean;
+    setConfig(config?: ParticleSystemConfig): void;
+    mount(): void;
+    unmount(): void;
+    reset(isPaused?: boolean): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    finish(): void;
+    tick(time?: number): void;
+    private startFrame;
+    private spawnOverTime;
+    private spawn;
+    private nextIndex;
+    private step;
+    private finishIfDrained;
+}
+//# sourceMappingURL=ParticleSystemController.d.ts.map

package/dist/ParticleSystemController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleSystemController.d.ts","sourceRoot":"","sources":["../src/ParticleSystemController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAUlC,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAItE,qBAAa,wBAAwB;IAEjC,OAAO,cAAqB;IAC5B,MAAM,cAAqB;IAC3B,OAAO,cAAqB;IAC5B,QAAQ,cAAqB;IAE7B,SAAS,0CAAiC;IAC1C,MAAM;;;;;;;;;;;;;;;;;;;;;MAA2B;IAEjC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAEV;gBAES,MAAM,GAAE,oBAAyB;IAI7C,IAAI,SAAS,YAEZ;IAED,IAAI,SAAS,YAEZ;IAED,IAAI,QAAQ,YAEX;IAED,SAAS,CAAC,MAAM,GAAE,oBAAyB;IAS3C,KAAK;IAKL,OAAO;IAKP,KAAK,CAAC,QAAQ,UAAgB;IAc9B,KAAK;IAQL,MAAM;IAUN,IAAI;IAIJ,MAAM;IASN,IAAI,CAAC,IAAI,SAAoB;IAY7B,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,KAAK;IAUb,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,IAAI;IAUZ,OAAO,CAAC,eAAe;CAM1B"}

package/dist/components/ParticleSystem.vue.d.ts

@@ -0,0 +1,47 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    controller: {
+        type: ObjectConstructor;
+    };
+    config: {
+        type: ObjectConstructor;
+    };
+}>, {}, {
+    localController: null;
+    eventCleanups: never[];
+}, {
+    particleController(): Record<string, any> | null;
+    isRunning(): any;
+    isPaused(): any;
+}, {
+    mountController(controller: any): void;
+    unmountController(): void;
+    reset(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    getParticleStyle(particle: any): {
+        position: string;
+        top: number;
+        left: number;
+        width: string;
+        height: string;
+        opacity: any;
+        transform: string;
+        'transform-origin': string;
+        'will-change': string;
+    };
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("started" | "paused" | "resumed" | "finished")[], "started" | "paused" | "resumed" | "finished", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    controller: {
+        type: ObjectConstructor;
+    };
+    config: {
+        type: ObjectConstructor;
+    };
+}>> & Readonly<{
+    onStarted?: ((...args: any[]) => any) | undefined;
+    onPaused?: ((...args: any[]) => any) | undefined;
+    onResumed?: ((...args: any[]) => any) | undefined;
+    onFinished?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, "isPaused" | "reset" | "pause" | "resume" | "stop" | "isRunning", import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=ParticleSystem.vue.d.ts.map

package/dist/components/ParticleSystem.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleSystem.vue.d.ts","sourceRoot":"","sources":["../../src/components/ParticleSystem.vue"],"names":[],"mappings":"AAWA;"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { default as ParticleSystem } from './components/ParticleSystem.vue';
+export * from './particles.js';
+export * from './ParticleSystemController.js';
+export * from './types.js';
+export { ParticleSystem, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,cAAc,MAAM,iCAAiC,CAAC;AAE7D,cAAc,gBAAgB,CAAC;AAC/B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,YAAY,CAAC;AAE3B,OAAO,EACH,cAAc,GACjB,CAAC"}

package/dist/particle-system.css

@@ -0,0 +1 @@
+@layer nightshade-components{.ParticleSystem[data-v-47a4e782]{position:relative}}

package/dist/particle-system.mjs

@@ -0,0 +1,400 @@
+import { reactive as E, openBlock as N, createElementBlock as j, Fragment as H, renderList as J, renderSlot as K, normalizeStyle as W } from "vue";
+class O {
+  constructor() {
+    this._groups = /* @__PURE__ */ new Map();
+  }
+  on(e, s = /* @__PURE__ */ Symbol()) {
+    let i = this._groups.get(s);
+    return i || (i = /* @__PURE__ */ new Set(), this._groups.set(s, i)), i.add(e), () => this.remove(e, s);
+  }
+  once(e, s = /* @__PURE__ */ Symbol()) {
+    const i = (n) => {
+      e(n), this.remove(i, s);
+    };
+    return this.on(i, s);
+  }
+  remove(e, s) {
+    const i = this._groups.get(s);
+    i && (i.delete(e), i.size === 0 && this._groups.delete(s));
+  }
+  removeAll(e) {
+    this._groups.delete(e);
+  }
+  emit(e) {
+    for (const s of this._groups.values())
+      for (const i of s)
+        i(e);
+  }
+}
+function c(t, e) {
+  return [t, e];
+}
+function X(t) {
+  return Math.hypot(t[0], t[1]);
+}
+function Z(t) {
+  const e = X(t);
+  return e === 0 ? c(0, 0) : c(t[0] / e, t[1] / e);
+}
+function q(t, e) {
+  return c(t[0] + e[0], t[1] + e[1]);
+}
+function U(t, e) {
+  return c(t[0] * e, t[1] * e);
+}
+const B = /* @__PURE__ */ Math.sqrt(3), tt = 0.5 * (B - 1), A = (3 - B) / 6, k = (t) => Math.floor(t) | 0, G = /* @__PURE__ */ new Float64Array([
+  1,
+  1,
+  -1,
+  1,
+  1,
+  -1,
+  -1,
+  -1,
+  1,
+  0,
+  -1,
+  0,
+  1,
+  0,
+  -1,
+  0,
+  0,
+  1,
+  0,
+  -1,
+  0,
+  1,
+  0,
+  -1
+]);
+function et(t = Math.random) {
+  const e = st(t), s = new Float64Array(e).map((n) => G[n % 12 * 2]), i = new Float64Array(e).map((n) => G[n % 12 * 2 + 1]);
+  return function(r, o) {
+    let m = 0, f = 0, d = 0;
+    const P = (r + o) * tt, _ = k(r + P), S = k(o + P), R = (_ + S) * A, Q = _ - R, Y = S - R, h = r - Q, u = o - Y;
+    let w, x;
+    h > u ? (w = 1, x = 0) : (w = 0, x = 1);
+    const M = h - w + A, b = u - x + A, z = h - 1 + 2 * A, F = u - 1 + 2 * A, V = _ & 255, $ = S & 255;
+    let p = 0.5 - h * h - u * u;
+    if (p >= 0) {
+      const l = V + e[$], v = s[l], C = i[l];
+      p *= p, m = p * p * (v * h + C * u);
+    }
+    let y = 0.5 - M * M - b * b;
+    if (y >= 0) {
+      const l = V + w + e[$ + x], v = s[l], C = i[l];
+      y *= y, f = y * y * (v * M + C * b);
+    }
+    let g = 0.5 - z * z - F * F;
+    if (g >= 0) {
+      const l = V + 1 + e[$ + 1], v = s[l], C = i[l];
+      g *= g, d = g * g * (v * z + C * F);
+    }
+    return 70 * (m + f + d);
+  };
+}
+function st(t) {
+  const s = new Uint8Array(512);
+  for (let i = 0; i < 512 / 2; i++)
+    s[i] = i;
+  for (let i = 0; i < 512 / 2 - 1; i++) {
+    const n = i + ~~(t() * (256 - i)), r = s[i];
+    s[i] = s[n], s[n] = r;
+  }
+  for (let i = 256; i < 512; i++)
+    s[i] = s[i - 256];
+  return s;
+}
+const it = {
+  seed: 1,
+  isPaused: !1,
+  startCount: 24,
+  rateOverTime: 0,
+  lifetime: 1,
+  shape: [0, 0],
+  size: 16,
+  sizeOverTime: 0,
+  scale: [1, 1],
+  scaleOverTime: [0, 0],
+  opacity: 1,
+  opacityOverTime: 0,
+  linearVelocity: [0, 0],
+  linearAcceleration: [0, 0],
+  radialVelocity: 0,
+  radialAcceleration: 0,
+  rotation: 0,
+  rotationOverTime: 0,
+  turbulence: 0,
+  noiseScale: 0.01
+};
+function L(t = {}) {
+  return {
+    ...it,
+    ...t
+  };
+}
+function I(t) {
+  let e = t >>> 0;
+  return () => {
+    e += 1831565813;
+    let s = e;
+    return s = Math.imul(s ^ s >>> 15, s | 1), s ^= s + Math.imul(s ^ s >>> 7, s | 61), ((s ^ s >>> 14) >>> 0) / 4294967296;
+  };
+}
+function nt(t, e, s) {
+  const i = T(e.shape, s), n = s() * Math.PI * 2, r = Math.sqrt(s()), o = c(
+    Math.cos(n) * r * i[0],
+    Math.sin(n) * r * i[1]
+  ), m = X(o) === 0 ? c(Math.cos(n), Math.sin(n)) : Z(o), f = T(e.linearVelocity, s), d = a(e.radialVelocity, s), P = U(m, d);
+  return {
+    index: t,
+    age: 0,
+    lifetime: Math.max(1e-3, a(e.lifetime, s)),
+    position: o,
+    velocity: f,
+    effectiveVelocity: q(f, P),
+    radialDirection: m,
+    size: a(e.size, s),
+    sizeOverTime: a(e.sizeOverTime, s),
+    scale: T(e.scale, s),
+    scaleOverTime: T(e.scaleOverTime, s),
+    opacity: a(e.opacity, s),
+    opacityOverTime: a(e.opacityOverTime, s),
+    linearAcceleration: T(e.linearAcceleration, s),
+    radialVelocity: d,
+    radialAcceleration: a(e.radialAcceleration, s),
+    rotation: a(e.rotation, s),
+    rotationOverTime: a(e.rotationOverTime, s),
+    turbulence: a(e.turbulence, s),
+    noiseScale: a(e.noiseScale, s),
+    t: 0
+  };
+}
+function rt(t, e, s) {
+  t.age += e, t.radialVelocity += t.radialAcceleration * e, t.velocity[0] += (t.linearAcceleration[0] + s(
+    t.position[0] * t.noiseScale,
+    t.position[1] * t.noiseScale
+  ) * t.turbulence) * e, t.velocity[1] += (t.linearAcceleration[1] + s(
+    t.position[0] * t.noiseScale + 100,
+    t.position[1] * t.noiseScale - 100
+  ) * t.turbulence) * e;
+  const i = U(t.radialDirection, t.radialVelocity);
+  t.effectiveVelocity = q(t.velocity, i), t.position[0] += t.effectiveVelocity[0] * e, t.position[1] += t.effectiveVelocity[1] * e, t.size += t.sizeOverTime * e, t.scale[0] += t.scaleOverTime[0] * e, t.scale[1] += t.scaleOverTime[1] * e, t.opacity += t.opacityOverTime * e, t.rotation += t.rotationOverTime * e, t.t = Math.min(1, t.age / t.lifetime);
+}
+function D(t) {
+  return et(t);
+}
+function a(t, e) {
+  return Array.isArray(t) ? t[0] + (t[1] - t[0]) * e() : t;
+}
+function T(t, e) {
+  if (ot(t)) {
+    const [s, i] = t;
+    return c(
+      s[0] + (i[0] - s[0]) * e(),
+      s[1] + (i[1] - s[1]) * e()
+    );
+  }
+  return c(t[0], t[1]);
+}
+function ot(t) {
+  return Array.isArray(t[0]);
+}
+const at = Number.MAX_SAFE_INTEGER;
+class lt {
+  constructor(e = {}) {
+    this.started = new O(), this.paused = new O(), this.resumed = new O(), this.finished = new O(), this.particles = E([]), this.config = L(), this.index = 0, this.spawnAccumulator = 0, this.random = I(this.config.seed), this.noise = D(this.random), this.lastTime = 0, this.frame = 0, this.mounted = !1, this.state = E({
+      isPaused: this.config.isPaused
+    }), this.setConfig(e);
+  }
+  get isDrained() {
+    return this.config.rateOverTime === 0 && this.particles.length === 0;
+  }
+  get isRunning() {
+    return !this.state.isPaused;
+  }
+  get isPaused() {
+    return this.state.isPaused;
+  }
+  setConfig(e = {}) {
+    const s = this.config.seed;
+    this.config = L(e), this.config.seed !== s && (this.random = I(this.config.seed), this.noise = D(this.random));
+  }
+  mount() {
+    this.mounted = !0, this.reset(this.config.isPaused);
+  }
+  unmount() {
+    this.mounted = !1, cancelAnimationFrame(this.frame);
+  }
+  reset(e = this.isPaused) {
+    this.particles.splice(0), this.index = 0, this.spawnAccumulator = 0, this.lastTime = performance.now(), this.state.isPaused = e, this.random = I(this.config.seed), this.noise = D(this.random), this.spawn(this.config.startCount), this.started.emit(), this.finishIfDrained(), this.startFrame();
+  }
+  pause() {
+    this.isPaused || (this.state.isPaused = !0, this.paused.emit());
+  }
+  resume() {
+    this.isPaused && (this.state.isPaused = !1, this.lastTime = performance.now(), this.resumed.emit(), this.startFrame());
+  }
+  stop() {
+    this.reset(!0);
+  }
+  finish() {
+    this.isPaused || (this.state.isPaused = !0, cancelAnimationFrame(this.frame), this.finished.emit());
+  }
+  tick(e = performance.now()) {
+    if (this.isPaused) {
+      this.lastTime = e;
+      return;
+    }
+    const s = Math.min(0.05, Math.max(0, (e - this.lastTime) / 1e3));
+    this.lastTime = e, this.spawnOverTime(s), this.step(s), this.finishIfDrained();
+  }
+  startFrame() {
+    !this.mounted || this.isPaused || (cancelAnimationFrame(this.frame), this.frame = requestAnimationFrame((e) => {
+      this.tick(e), this.startFrame();
+    }));
+  }
+  spawnOverTime(e) {
+    this.spawnAccumulator += this.config.rateOverTime * e;
+    const s = Math.floor(this.spawnAccumulator);
+    this.spawnAccumulator -= s, this.spawn(s);
+  }
+  spawn(e) {
+    for (let s = 0; s < e; s++)
+      this.particles.push(nt(
+        this.nextIndex(),
+        this.config,
+        this.random
+      ));
+  }
+  nextIndex() {
+    const e = this.index;
+    return this.index = e === at ? 0 : e + 1, e;
+  }
+  step(e) {
+    for (let s = this.particles.length - 1; s >= 0; s--) {
+      const i = this.particles[s];
+      rt(i, e, this.noise), i.age >= i.lifetime && this.particles.splice(s, 1);
+    }
+  }
+  finishIfDrained() {
+    this.isRunning && this.isDrained && this.finish();
+  }
+}
+const ct = (t, e) => {
+  const s = t.__vccOpts || t;
+  for (const [i, n] of e)
+    s[i] = n;
+  return s;
+}, ht = {
+  props: {
+    controller: { type: Object },
+    config: { type: Object }
+  },
+  emits: [
+    "started",
+    "paused",
+    "resumed",
+    "finished"
+  ],
+  expose: [
+    "reset",
+    "pause",
+    "resume",
+    "stop",
+    "isRunning",
+    "isPaused"
+  ],
+  data() {
+    return {
+      localController: null,
+      eventCleanups: []
+    };
+  },
+  computed: {
+    particleController() {
+      return this.controller ?? this.localController;
+    },
+    isRunning() {
+      return this.particleController.isRunning;
+    },
+    isPaused() {
+      return this.particleController.isPaused;
+    }
+  },
+  watch: {
+    config: {
+      deep: !0,
+      handler(t) {
+        t != null && this.particleController?.setConfig(t);
+      }
+    },
+    controller(t, e) {
+      e?.unmount(), this.unmountController(), this.mountController(t ?? this.localController);
+    }
+  },
+  created() {
+    this.localController = new lt(this.config ?? {});
+  },
+  mounted() {
+    this.mountController(this.particleController);
+  },
+  beforeUnmount() {
+    this.unmountController();
+  },
+  methods: {
+    mountController(t) {
+      this.config != null && t.setConfig(this.config), t.started.on(() => this.$emit("started"), this), t.paused.on(() => this.$emit("paused"), this), t.resumed.on(() => this.$emit("resumed"), this), t.finished.on(() => this.$emit("finished"), this), t.mount();
+    },
+    unmountController() {
+      this.particleController && (this.particleController.started.removeAll(this), this.particleController.paused.removeAll(this), this.particleController.resumed.removeAll(this), this.particleController.finished.removeAll(this), this.particleController.unmount());
+    },
+    reset() {
+      this.particleController.reset();
+    },
+    pause() {
+      this.particleController.pause();
+    },
+    resume() {
+      this.particleController.resume();
+    },
+    stop() {
+      this.particleController.stop();
+    },
+    getParticleStyle(t) {
+      const e = Math.max(0, t.size);
+      return {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: `${e}px`,
+        height: `${e}px`,
+        opacity: t.opacity,
+        transform: `translate(${t.position[0]}px, ${t.position[1]}px) rotate(${t.rotation}deg) scale(${t.scale[0]}, ${t.scale[1]})`,
+        "transform-origin": "center",
+        "will-change": "transform, opacity"
+      };
+    }
+  }
+}, ut = { class: "ParticleSystem" };
+function mt(t, e, s, i, n, r) {
+  return N(), j("div", ut, [
+    (N(!0), j(H, null, J(r.particleController.particles, (o) => K(t.$slots, "default", {
+      key: o.index,
+      particle: o,
+      style: W(r.getParticleStyle(o))
+    }, void 0, !0)), 128))
+  ]);
+}
+const dt = /* @__PURE__ */ ct(ht, [["render", mt], ["__scopeId", "data-v-47a4e782"]]);
+export {
+  it as DEFAULT_PARTICLE_CONFIG,
+  dt as ParticleSystem,
+  lt as ParticleSystemController,
+  D as createNoise,
+  nt as createParticle,
+  I as createRandom,
+  L as resolveParticleConfig,
+  rt as stepParticle
+};

package/dist/particles.d.ts

@@ -0,0 +1,31 @@
+import { createNoise2D } from 'simplex-noise';
+import { NumberValue, ParticleState, ParticleSystemConfig, Vector2Value } from './types.js';
+export type ResolvedParticleSystemConfig = Required<ParticleSystemConfig>;
+export declare const DEFAULT_PARTICLE_CONFIG: ResolvedParticleSystemConfig;
+export declare function resolveParticleConfig(config?: ParticleSystemConfig): {
+    seed: number;
+    isPaused: boolean;
+    startCount: number;
+    rateOverTime: number;
+    lifetime: NumberValue;
+    shape: Vector2Value;
+    size: NumberValue;
+    sizeOverTime: NumberValue;
+    scale: Vector2Value;
+    scaleOverTime: Vector2Value;
+    opacity: NumberValue;
+    opacityOverTime: NumberValue;
+    linearVelocity: Vector2Value;
+    linearAcceleration: Vector2Value;
+    radialVelocity: NumberValue;
+    radialAcceleration: NumberValue;
+    rotation: NumberValue;
+    rotationOverTime: NumberValue;
+    turbulence: NumberValue;
+    noiseScale: NumberValue;
+};
+export declare function createRandom(seed: number): () => number;
+export declare function createParticle(index: number, config: ReturnType<typeof resolveParticleConfig>, random: () => number): ParticleState;
+export declare function stepParticle(particle: ParticleState, dt: number, noise: ReturnType<typeof createNoise2D>): void;
+export declare function createNoise(random: () => number): import('simplex-noise').NoiseFunction2D;
+//# sourceMappingURL=particles.d.ts.map

package/dist/particles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../src/particles.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EACR,WAAW,EACX,aAAa,EACb,oBAAoB,EAEpB,YAAY,EACf,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC;AAE1E,eAAO,MAAM,uBAAuB,EAAE,4BAqBrC,CAAC;AAEF,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,oBAAyB;;;;;;;;;;;;;;;;;;;;;EAKtE;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,gBASxC;AAED,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,EAChD,MAAM,EAAE,MAAM,MAAM,GACrB,aAAa,CAqCf;AAED,wBAAgB,YAAY,CACxB,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,QA4B1C;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,MAAM,2CAE/C"}

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+import { Vector2 } from '@nightshadeui/util/vector2';
+export type NumberRange = [number, number];
+export type Vector2Range = [Vector2, Vector2];
+export type NumberValue = number | NumberRange;
+export type Vector2Value = Vector2 | Vector2Range;
+export interface ParticleSystemConfig {
+    seed?: number;
+    isPaused?: boolean;
+    startCount?: number;
+    rateOverTime?: number;
+    lifetime?: NumberValue;
+    shape?: Vector2Value;
+    size?: NumberValue;
+    sizeOverTime?: NumberValue;
+    scale?: Vector2Value;
+    scaleOverTime?: Vector2Value;
+    opacity?: NumberValue;
+    opacityOverTime?: NumberValue;
+    linearVelocity?: Vector2Value;
+    linearAcceleration?: Vector2Value;
+    radialVelocity?: NumberValue;
+    radialAcceleration?: NumberValue;
+    rotation?: NumberValue;
+    rotationOverTime?: NumberValue;
+    turbulence?: NumberValue;
+    noiseScale?: NumberValue;
+}
+export interface ParticleState {
+    index: number;
+    age: number;
+    lifetime: number;
+    position: Vector2;
+    velocity: Vector2;
+    effectiveVelocity: Vector2;
+    radialDirection: Vector2;
+    size: number;
+    sizeOverTime: number;
+    scale: Vector2;
+    scaleOverTime: Vector2;
+    opacity: number;
+    opacityOverTime: number;
+    linearAcceleration: Vector2;
+    radialVelocity: number;
+    radialAcceleration: number;
+    rotation: number;
+    rotationOverTime: number;
+    turbulence: number;
+    noiseScale: number;
+    t: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAE1D,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC3C,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAE9C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,WAAW,CAAC;AAC/C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,YAAY,CAAC;AAElD,MAAM,WAAW,oBAAoB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,eAAe,CAAC,EAAE,WAAW,CAAC;IAC9B,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,kBAAkB,CAAC,EAAE,YAAY,CAAC;IAClC,cAAc,CAAC,EAAE,WAAW,CAAC;IAC7B,kBAAkB,CAAC,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAC/B,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,UAAU,CAAC,EAAE,WAAW,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;CACb"}

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@nightshadeui/particle-system",
+    "version": "2.15.0",
+    "description": "Nightshade particle system component",
+    "author": "Boris Okunskiy",
+    "license": "ISC",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/particle-system.mjs"
+        },
+        "./css": "./dist/particle-system.css",
+        "./src": "./src/index.ts"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build:watch": "vite build --watch",
+        "build": "NODE_ENV=production vite build"
+    },
+    "peerDependencies": {
+        "vue": "^3.5.22"
+    },
+    "dependencies": {
+        "@nightshadeui/util": "2.15.0",
+        "nanoevent": "^1.0.0",
+        "simplex-noise": "^4.0.3"
+    }
+}