@sarthak03dot/romantic-animations 1.0.3 → 1.2.0

package/src/animations/confetti.js

@@ -0,0 +1,92 @@
+import { mergeOptions } from '../core/engine.js';
+
+const DEFAULTS = {
+  density: 0.18,
+  colors: ['#ff6b8a','#ff4d6d','#ffd6ff','#e7c6ff','#c77dff','#48cae4','#ffe66d','#06d6a0'],
+  minSize: 6,
+  maxSize: 14,
+  minSpeed: 1.5,
+  maxSpeed: 4,
+  gravity: 0.06,
+  drag: 0.99,
+  shapes: ['rect', 'circle', 'ribbon'],
+};
+
+export function confetti(canvas, userOptions = {}) {
+  const opts = mergeOptions(DEFAULTS, userOptions);
+  const ctx = canvas.getContext('2d');
+  const pieces = [];
+  let running = true;
+
+  function createPiece() {
+    const size = opts.minSize + Math.random() * (opts.maxSize - opts.minSize);
+    const speed = opts.minSpeed + Math.random() * (opts.maxSpeed - opts.minSpeed);
+    return {
+      x: Math.random() * canvas.width,
+      y: -size * 2,
+      w: size,
+      h: size * (0.4 + Math.random() * 0.8),
+      vx: (Math.random() - 0.5) * 3,
+      vy: speed,
+      angle: Math.random() * Math.PI * 2,
+      spin: (Math.random() - 0.5) * 0.15,
+      color: opts.colors[Math.floor(Math.random() * opts.colors.length)],
+      alpha: 0.8 + Math.random() * 0.2,
+      shape: opts.shapes[Math.floor(Math.random() * opts.shapes.length)],
+    };
+  }
+
+  function drawPiece(p) {
+    ctx.save();
+    ctx.globalAlpha = p.alpha;
+    ctx.fillStyle = p.color;
+    ctx.strokeStyle = p.color;
+    ctx.translate(p.x, p.y);
+    ctx.rotate(p.angle);
+
+    if (p.shape === 'circle') {
+      ctx.beginPath();
+      ctx.ellipse(0, 0, p.w / 2, p.h / 2, 0, 0, Math.PI * 2);
+      ctx.fill();
+    } else if (p.shape === 'ribbon') {
+      ctx.beginPath();
+      ctx.moveTo(-p.w / 2, 0);
+      ctx.quadraticCurveTo(0, -p.h, p.w / 2, 0);
+      ctx.quadraticCurveTo(0, p.h, -p.w / 2, 0);
+      ctx.fill();
+    } else {
+      ctx.fillRect(-p.w / 2, -p.h / 2, p.w, p.h);
+    }
+    ctx.restore();
+  }
+
+  function animate() {
+    if (!running) return;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    if (Math.random() < opts.density) pieces.push(createPiece());
+
+    for (let i = pieces.length - 1; i >= 0; i--) {
+      const p = pieces[i];
+      p.vy += opts.gravity;
+      p.vx *= opts.drag;
+      p.vy *= opts.drag;
+      p.x += p.vx;
+      p.y += p.vy;
+      p.angle += p.spin;
+
+      drawPiece(p);
+
+      if (p.y > canvas.height + 20) pieces.splice(i, 1);
+    }
+
+    requestAnimationFrame(animate);
+  }
+
+  animate();
+
+  return function stop() {
+    running = false;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+  };
+}

package/src/animations/fireworks.js

@@ -0,0 +1,112 @@
+import { mergeOptions } from '../core/engine.js';
+
+const DEFAULTS = {
+  interval: 1200,       // ms between auto-launches
+  trailLength: 28,
+  particleCount: 80,
+  colors: ['#ff6b8a','#ff4d6d','#ffd6ff','#e7c6ff','#ffe66d','#06d6a0','#48cae4','#ffffff'],
+  gravity: 0.09,
+  decay: 0.014,
+  glow: true,
+};
+
+export function fireworks(canvas, userOptions = {}) {
+  const opts = mergeOptions(DEFAULTS, userOptions);
+  const ctx = canvas.getContext('2d');
+  let running = true;
+
+  const rockets = [];    // { x, y, vx, vy, trail[], color }
+  const particles = [];  // burst particles
+
+  function launchRocket() {
+    const x = canvas.width * (0.2 + Math.random() * 0.6);
+    const targetY = canvas.height * (0.1 + Math.random() * 0.4);
+    const dy = targetY - canvas.height;
+    const speed = 8 + Math.random() * 5;
+    const color = opts.colors[Math.floor(Math.random() * opts.colors.length)];
+    rockets.push({ x, y: canvas.height, vy: -Math.abs(speed), targetY, trail: [], color });
+  }
+
+  function burst(x, y, color) {
+    for (let i = 0; i < opts.particleCount; i++) {
+      const angle = Math.random() * Math.PI * 2;
+      const speed = 1 + Math.random() * 5;
+      particles.push({
+        x, y,
+        vx: Math.cos(angle) * speed,
+        vy: Math.sin(angle) * speed,
+        alpha: 1,
+        decay: opts.decay * (0.7 + Math.random() * 0.6),
+        size: 2 + Math.random() * 3,
+        color,
+      });
+    }
+  }
+
+  // Auto-launch interval
+  const iv = setInterval(() => { if (running) launchRocket(); }, opts.interval);
+  launchRocket(); // fire one immediately
+
+  function animate() {
+    if (!running) return;
+
+    // Clear canvas instead of using a solid fill to keep background transparent
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    // Draw rockets
+    for (let i = rockets.length - 1; i >= 0; i--) {
+      const r = rockets[i];
+      r.y += r.vy;
+      r.trail.push({ x: r.x, y: r.y });
+      if (r.trail.length > opts.trailLength) r.trail.shift();
+
+      // Draw trail
+      for (let t = 0; t < r.trail.length; t++) {
+        const alpha = (t / r.trail.length) * 0.8;
+        ctx.save();
+        ctx.globalAlpha = alpha;
+        if (opts.glow) { ctx.shadowColor = r.color; ctx.shadowBlur = 6; }
+        ctx.fillStyle = r.color;
+        ctx.beginPath();
+        ctx.arc(r.trail[t].x, r.trail[t].y, 2.5 * (t / r.trail.length), 0, Math.PI * 2);
+        ctx.fill();
+        ctx.restore();
+      }
+
+      if (r.y <= r.targetY) {
+        burst(r.x, r.y, r.color);
+        rockets.splice(i, 1);
+      }
+    }
+
+    // Draw burst particles
+    for (let i = particles.length - 1; i >= 0; i--) {
+      const p = particles[i];
+      p.x += p.vx;
+      p.y += p.vy;
+      p.vy += opts.gravity;
+      p.alpha -= p.decay;
+
+      ctx.save();
+      ctx.globalAlpha = Math.max(0, p.alpha);
+      if (opts.glow) { ctx.shadowColor = p.color; ctx.shadowBlur = p.size * 2; }
+      ctx.fillStyle = p.color;
+      ctx.beginPath();
+      ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.restore();
+
+      if (p.alpha <= 0) particles.splice(i, 1);
+    }
+
+    requestAnimationFrame(animate);
+  }
+
+  animate();
+
+  return function stop() {
+    running = false;
+    clearInterval(iv);
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+  };
+}

package/src/animations/floatingHearts.js

@@ -1,35 +1,89 @@
-export function floatingHearts(canvas) {
-    const ctx = canvas.getContext("2d");
-    const hearts = [];
-  
-    function createHeart() {
-      return {
-        x: Math.random() * canvas.width,
-        y: canvas.height + 20,
-        size: 20 + Math.random() * 10,
-        speed: 1 + Math.random() * 2,
-      };
-    }
-  
-    function drawHeart(h) {
-      ctx.fillStyle = "pink";
-      ctx.beginPath();
-      ctx.moveTo(h.x, h.y);
-      ctx.bezierCurveTo(h.x + h.size / 2, h.y - h.size, h.x + h.size, h.y + h.size / 3, h.x, h.y + h.size);
-      ctx.bezierCurveTo(h.x - h.size, h.y + h.size / 3, h.x - h.size / 2, h.y - h.size, h.x, h.y);
-      ctx.fill();
-    }
-  
-    function animate() {
-      ctx.clearRect(0, 0, canvas.width, canvas.height);
-      if (Math.random() < 0.1) hearts.push(createHeart());
-      for (let i = 0; i < hearts.length; i++) {
-        hearts[i].y -= hearts[i].speed;
-        drawHeart(hearts[i]);
+import { mergeOptions } from '../core/engine.js';
+
+const DEFAULTS = {
+  count: 0.12,       // hearts spawned per frame (probability)
+  minSize: 14,
+  maxSize: 32,
+  minSpeed: 0.8,
+  maxSpeed: 2.4,
+  colors: ['#ff6b8a', '#ff4d6d', '#ff85a1', '#ffc2d1', '#ff0a54', '#ff477e'],
+  wobble: true,      // horizontal sine drift
+  glow: true,
+};
+
+/**
+ * Draw a proper heart shape centred at (cx, cy) with given radius.
+ */
+function drawHeartShape(ctx, cx, cy, r, color, alpha = 1, glow = false) {
+  ctx.save();
+  ctx.globalAlpha = alpha;
+  if (glow) {
+    ctx.shadowColor = color;
+    ctx.shadowBlur = r * 1.2;
+  }
+  ctx.fillStyle = color;
+  ctx.beginPath();
+  ctx.moveTo(cx, cy + r * 0.3);
+  // left lobe
+  ctx.bezierCurveTo(cx - r * 1.1, cy - r * 0.5, cx - r * 1.6, cy + r * 0.5, cx, cy + r * 1.4);
+  // right lobe
+  ctx.bezierCurveTo(cx + r * 1.6, cy + r * 0.5, cx + r * 1.1, cy - r * 0.5, cx, cy + r * 0.3);
+  ctx.fill();
+  ctx.restore();
+}
+
+export function floatingHearts(canvas, userOptions = {}) {
+  const opts = mergeOptions(DEFAULTS, userOptions);
+  const ctx = canvas.getContext('2d');
+  const hearts = [];
+  let running = true;
+  let frame = 0;
+
+  function createHeart() {
+    const size = opts.minSize + Math.random() * (opts.maxSize - opts.minSize);
+    return {
+      x: Math.random() * canvas.width,
+      y: canvas.height + size * 2,
+      size,
+      speed: opts.minSpeed + Math.random() * (opts.maxSpeed - opts.minSpeed),
+      color: opts.colors[Math.floor(Math.random() * opts.colors.length)],
+      alpha: 0.7 + Math.random() * 0.3,
+      wobbleOffset: Math.random() * Math.PI * 2,
+      wobbleSpeed: 0.02 + Math.random() * 0.03,
+      wobbleAmount: 0.5 + Math.random() * 1.5,
+    };
+  }
+
+  function animate() {
+    if (!running) return;
+    frame++;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    if (Math.random() < opts.count) hearts.push(createHeart());
+
+    for (let i = hearts.length - 1; i >= 0; i--) {
+      const h = hearts[i];
+      h.y -= h.speed;
+      h.wobbleOffset += h.wobbleSpeed;
+      const xOffset = opts.wobble ? Math.sin(h.wobbleOffset) * h.wobbleAmount * h.size * 0.5 : 0;
+
+      // Fade out near top
+      const fadeAlpha = Math.min(h.alpha, h.y / (canvas.height * 0.2));
+      if (fadeAlpha <= 0 || h.y < -h.size * 3) {
+        hearts.splice(i, 1);
+        continue;
       }
-      requestAnimationFrame(animate);
+
+      drawHeartShape(ctx, h.x + xOffset, h.y, h.size, h.color, Math.max(0, fadeAlpha), opts.glow);
     }
-  
-    animate();
+
+    requestAnimationFrame(animate);
   }
-  
+
+  animate();
+
+  return function stop() {
+    running = false;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+  };
+}

package/src/animations/floatingOrbs.js

@@ -0,0 +1,76 @@
+import { mergeOptions } from '../core/engine.js';
+
+const DEFAULTS = {
+  orbCount: 15,
+  minSize: 50,
+  maxSize: 150,
+  colors: ['#ff4d6d', '#c77dff', '#48cae4', '#ffe66d'],
+  speed: 0.5,
+  glow: true,
+};
+
+export function floatingOrbs(canvas, userOptions = {}) {
+  const opts = mergeOptions(DEFAULTS, userOptions);
+  const ctx = canvas.getContext('2d');
+  const orbs = [];
+  let running = true;
+
+  function createOrb() {
+    const size = opts.minSize + Math.random() * (opts.maxSize - opts.minSize);
+    return {
+      x: Math.random() * canvas.width,
+      y: Math.random() * canvas.height,
+      size,
+      vx: (Math.random() - 0.5) * opts.speed,
+      vy: (Math.random() - 0.5) * opts.speed,
+      color: opts.colors[Math.floor(Math.random() * opts.colors.length)],
+      alpha: 0,
+    };
+  }
+
+  for (let i = 0; i < opts.orbCount; i++) {
+    const orb = createOrb();
+    orb.alpha = Math.random() * 0.5 + 0.1;
+    orbs.push(orb);
+  }
+
+  function animate() {
+    if (!running) return;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    for (let i = 0; i < orbs.length; i++) {
+      const b = orbs[i];
+      b.x += b.vx;
+      b.y += b.vy;
+
+      // Bounce off walls
+      if (b.x < -b.size) b.x = canvas.width + b.size;
+      if (b.x > canvas.width + b.size) b.x = -b.size;
+      if (b.y < -b.size) b.y = canvas.height + b.size;
+      if (b.y > canvas.height + b.size) b.y = -b.size;
+
+      ctx.save();
+      ctx.globalAlpha = b.alpha;
+      ctx.globalCompositeOperation = 'screen';
+      
+      const gradient = ctx.createRadialGradient(b.x, b.y, 0, b.x, b.y, b.size);
+      gradient.addColorStop(0, b.color);
+      gradient.addColorStop(1, 'rgba(0,0,0,0)');
+      
+      ctx.fillStyle = gradient;
+      ctx.beginPath();
+      ctx.arc(b.x, b.y, b.size, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.restore();
+    }
+
+    requestAnimationFrame(animate);
+  }
+
+  animate();
+
+  return function stop() {
+    running = false;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+  };
+}

package/src/animations/heartBurst.js

@@ -1,56 +1,113 @@
-export function heartBurst(canvas) {
-    const ctx = canvas.getContext("2d");
-    const bursts = [];
-  
-    function createHeart(x, y) {
+import { mergeOptions } from '../core/engine.js';
+
+const DEFAULTS = {
+  count: 20,          // hearts per burst
+  minSize: 8,
+  maxSize: 20,
+  minSpeed: 2,
+  maxSpeed: 7,
+  gravity: 0.08,
+  decay: 0.018,
+  colors: ['#ff0a54', '#ff477e', '#ff7096', '#ff85a1', '#fbb1bd', '#ff4d6d'],
+  glow: true,
+  symbols: ['heart'], // 'heart' | 'star' | 'sparkle'
+};
+
+function drawSymbol(ctx, type, cx, cy, r, color, alpha, glow) {
+  ctx.save();
+  ctx.globalAlpha = Math.max(0, alpha);
+  if (glow) { ctx.shadowColor = color; ctx.shadowBlur = r * 2; }
+  ctx.fillStyle = color;
+
+  if (type === 'star') {
+    // 5-point star
+    ctx.beginPath();
+    for (let i = 0; i < 5; i++) {
+      const outer = (Math.PI / 2) + (i * 2 * Math.PI) / 5;
+      const inner = outer + Math.PI / 5;
+      if (i === 0) ctx.moveTo(cx + r * Math.cos(outer), cy - r * Math.sin(outer));
+      else ctx.lineTo(cx + r * Math.cos(outer), cy - r * Math.sin(outer));
+      ctx.lineTo(cx + (r * 0.4) * Math.cos(inner), cy - (r * 0.4) * Math.sin(inner));
+    }
+    ctx.closePath();
+    ctx.fill();
+  } else if (type === 'sparkle') {
+    // 4-point sparkle
+    for (let i = 0; i < 4; i++) {
+      const a = (i * Math.PI) / 2;
+      ctx.beginPath();
+      ctx.ellipse(cx + Math.cos(a) * r * 0.5, cy + Math.sin(a) * r * 0.5, r * 0.18, r * 0.7, a, 0, Math.PI * 2);
+      ctx.fill();
+    }
+  } else {
+    // heart
+    ctx.beginPath();
+    ctx.moveTo(cx, cy + r * 0.3);
+    ctx.bezierCurveTo(cx - r * 1.1, cy - r * 0.5, cx - r * 1.6, cy + r * 0.5, cx, cy + r * 1.4);
+    ctx.bezierCurveTo(cx + r * 1.6, cy + r * 0.5, cx + r * 1.1, cy - r * 0.5, cx, cy + r * 0.3);
+    ctx.fill();
+  }
+  ctx.restore();
+}
+
+export function heartBurst(canvas, userOptions = {}) {
+  const opts = mergeOptions(DEFAULTS, userOptions);
+  const ctx = canvas.getContext('2d');
+  const particles = [];
+  let running = true;
+
+  function spawnBurst(x, y) {
+    for (let i = 0; i < opts.count; i++) {
       const angle = Math.random() * Math.PI * 2;
-      const speed = 2 + Math.random() * 3;
-      return {
-        x,
-        y,
-        size: 10 + Math.random() * 5,
+      const speed = opts.minSpeed + Math.random() * (opts.maxSpeed - opts.minSpeed);
+      particles.push({
+        x, y,
+        size: opts.minSize + Math.random() * (opts.maxSize - opts.minSize),
         vx: Math.cos(angle) * speed,
         vy: Math.sin(angle) * speed,
         alpha: 1,
-        decay: 0.02
-      };
+        decay: opts.decay * (0.8 + Math.random() * 0.4),
+        color: opts.colors[Math.floor(Math.random() * opts.colors.length)],
+        symbol: opts.symbols[Math.floor(Math.random() * opts.symbols.length)],
+      });
     }
-  
-    function drawHeart(h) {
-      ctx.fillStyle = `rgba(255, 20, 147, ${h.alpha})`;
-      ctx.beginPath();
-      ctx.moveTo(h.x, h.y);
-      ctx.bezierCurveTo(h.x + h.size / 2, h.y - h.size, h.x + h.size, h.y + h.size / 3, h.x, h.y + h.size);
-      ctx.bezierCurveTo(h.x - h.size, h.y + h.size / 3, h.x - h.size / 2, h.y - h.size, h.x, h.y);
-      ctx.fill();
-    }
-  
-    canvas.addEventListener("click", (e) => {
-      const rect = canvas.getBoundingClientRect();
-      const burst = [];
-      for (let i = 0; i < 20; i++) {
-        burst.push(createHeart(e.clientX - rect.left, e.clientY - rect.top));
-      }
-      bursts.push(burst);
-    });
-  
-    function animate() {
-      ctx.clearRect(0, 0, canvas.width, canvas.height);
-      for (let b = bursts.length - 1; b >= 0; b--) {
-        const burst = bursts[b];
-        for (let i = burst.length - 1; i >= 0; i--) {
-          const h = burst[i];
-          h.x += h.vx;
-          h.y += h.vy;
-          h.alpha -= h.decay;
-          drawHeart(h);
-          if (h.alpha <= 0) burst.splice(i, 1);
-        }
-        if (burst.length === 0) bursts.splice(b, 1);
-      }
-      requestAnimationFrame(animate);
+  }
+
+  const onClick = (e) => {
+    const rect = canvas.getBoundingClientRect();
+    spawnBurst(e.clientX - rect.left, e.clientY - rect.top);
+  };
+  const onTouch = (e) => {
+    const rect = canvas.getBoundingClientRect();
+    Array.from(e.changedTouches).forEach((t) => spawnBurst(t.clientX - rect.left, t.clientY - rect.top));
+  };
+
+  window.addEventListener('click', onClick);
+  window.addEventListener('touchend', onTouch, { passive: true });
+
+  function animate() {
+    if (!running) return;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+    for (let i = particles.length - 1; i >= 0; i--) {
+      const p = particles[i];
+      p.x += p.vx;
+      p.y += p.vy;
+      p.vy += opts.gravity;     // gravity
+      p.alpha -= p.decay;
+      drawSymbol(ctx, p.symbol, p.x, p.y, p.size, p.color, p.alpha, opts.glow);
+      if (p.alpha <= 0) particles.splice(i, 1);
     }
-  
-    animate();
+
+    requestAnimationFrame(animate);
   }
-  
+
+  animate();
+
+  return function stop() {
+    running = false;
+    window.removeEventListener('click', onClick);
+    window.removeEventListener('touchend', onTouch);
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+  };
+}