# Sparkles

Bintang empat sisi dan titik kecil yang berkilau muncul dan memudar di sebuah area, di sekitar judul, atau memancar dari tengah saat hover.

- Kategori: Latar
- Status: stable
- Registry: https://markas.jenderalcorp.com/r/sparkles.json
- CLI: `npx markasui@latest add sparkles`

## Kapan dipakai

Sentuhan perayaan di layar sukses, judul peluncuran, kartu upgrade, atau empty state.

- Pakai text dengan padding pada komponen supaya bintang berada di sekitar judul, bukan di atasnya
- Pakai burst pada kartu yang berisi ajakan bertindak
- Jaga density di bawah 40 supaya teks tetap terbaca

## Kode

### Blade

Simpan di `resources/views/components/markas/sparkles.blade.php`. Tanpa dependensi tambahan.

```blade
@props([
    'variant' => 'field',
    'density' => 24,
    'size' => 'md',
    'color' => 'warning',
    'seed' => 5,
])

@php
    $base = 'group/sparkles relative isolate overflow-hidden';
    $layer = 'pointer-events-none absolute inset-0';
    $sparkle = 'absolute -translate-1/2 fill-current';
    $content = 'relative';
    $colors = [
        'muted' => 'text-muted',
        'ink' => 'text-ink',
        'primary' => 'text-primary',
        'success' => 'text-success',
        'warning' => 'text-warning',
        'danger' => 'text-danger',
    ];
    $twinkle = 'animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none';
    $variants = [
        'field' => $twinkle,
        'text' => $twinkle,
        'burst' => 'top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]',
    ];
    // Ukuran terkecil dan rentang tambahan dalam piksel.
    $sizes = ['sm' => [4, 4], 'md' => [6, 6], 'lg' => [10, 8]];
    $star = 'M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z';
    $keyframes = '@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}';

    // Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan kilau yang sama.
    $modulus = 2147483647;
    $multiplier = 48271;
    $maxSparkles = 120;
    $burstX = 240;
    $burstY = 140;
    $burstDelayMs = 600;
    $edge = 1500;

    $key = array_key_exists($variant, $variants) ? $variant : 'field';
    [$minSize, $sizeRange] = $sizes[$size] ?? $sizes['md'];

    $state = abs((int) $seed) % ($modulus - 1) + 1;
    $next = function () use (&$state, $modulus, $multiplier) {
        return $state = ($state * $multiplier) % $modulus;
    };
    // Posisi dalam persen: acak di seluruh area (field), atau di pita tepi atas, bawah, kiri, kanan (text).
    $place = function () use ($key, $next, $edge) {
        if ($key === 'field') {
            $left = ($next() % 10000) / 100;

            return [$left, ($next() % 10000) / 100];
        }
        $side = $next() % 4;
        $along = ($next() % 10000) / 100;
        $near = ($next() % $edge) / 100;
        $far = (10000 - $next() % $edge) / 100;

        return [[$along, $along, $near, $far][$side], [$near, $far, $along, $along][$side]];
    };

    $items = [];
    $total = max(0, min((int) $density, $maxSparkles));
    for ($i = 0; $i < $total; $i++) {
        $px = ($minSize + $next() % $sizeRange).'px';
        $dot = $key === 'field' && $next() % 3 === 0;
        if ($key === 'burst') {
            $style = 'width: '.$px.'; height: '.$px.'; animation-delay: '.($next() % $burstDelayMs).'ms; --markas-sparkle-x: '.($next() % $burstX - $burstX / 2).'px; --markas-sparkle-y: '.($next() % $burstY - $burstY / 2).'px';
        } else {
            [$left, $top] = $place();
            $style = 'left: '.$left.'%; top: '.$top.'%; width: '.$px.'; height: '.$px.'; opacity: '.((($next() % 5) + 5) / 10).'; animation-delay: '.(($next() % 30) * 100).'ms; animation-duration: '.(($next() % 3) + 2).'s';
        }
        $items[] = ['dot' => $dot, 'style' => $style];
    }
@endphp

<div {{ $attributes->class([$base]) }}>
    <style>{!! $keyframes !!}</style>
    <div aria-hidden="true" wire:ignore @class([$layer, $colors[$color] ?? $colors['warning']])>
        @foreach ($items as $item)
            <svg class="{{ $sparkle }} {{ $variants[$key] }}" style="{{ $item['style'] }}" viewBox="0 0 24 24">
                @if ($item['dot'])
                    <circle cx="12" cy="12" r="5" />
                @else
                    <path d="{{ $star }}" />
                @endif
            </svg>
        @endforeach
    </div>
    <div class="{{ $content }}">{{ $slot }}</div>
</div>
```

```blade
<x-markas.sparkles variant="field" :density="36" color="warning" class="rounded-xl border border-line bg-surface px-6 py-12">
    <h2 class="text-2xl font-semibold text-ink">Workspace kamu sudah siap</h2>
    <x-markas.button>Buka dasbor</x-markas.button>
</x-markas.sparkles>

<x-markas.sparkles variant="text" size="sm" class="px-6 py-4">
    <h2 class="text-3xl font-semibold text-ink">Kenalan dengan Markas Pro</h2>
</x-markas.sparkles>
```

Tidak butuh JavaScript atau Alpine.js.

### React

Simpan di `src/components/markas/Sparkles.tsx`. Tanpa dependensi tambahan.

```tsx
import type { ComponentProps, CSSProperties } from "react";

const base = "group/sparkles relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const sparkle = "absolute -translate-1/2 fill-current";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const twinkle =
  "animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none";
const variants = {
  field: twinkle,
  text: twinkle,
  burst:
    "top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]",
};
/** Ukuran terkecil dan rentang tambahan dalam piksel. */
const sizes = { sm: [4, 4], md: [6, 6], lg: [10, 8] } as const;
const star =
  "M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z";
const keyframes =
  "@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}";
const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");

/** Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan kilau yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_SPARKLES = 120;
const BURST_X = 240;
const BURST_Y = 140;
const BURST_DELAY_MS = 600;
const EDGE = 1500;

type Variant = keyof typeof variants;

/** Posisi dalam persen: acak di seluruh area (field), atau di pita tepi atas, bawah, kiri, kanan (text). */
function place(variant: Variant, next: () => number) {
  if (variant === "field")
    return [(next() % 10000) / 100, (next() % 10000) / 100];
  const side = next() % 4;
  const along = (next() % 10000) / 100;
  const near = (next() % EDGE) / 100;
  const far = (10000 - (next() % EDGE)) / 100;
  return [[along, along, near, far][side], [near, far, along, along][side]];
}

function makeSparkles(
  variant: Variant,
  density: number,
  seed: number,
  size: keyof typeof sizes,
) {
  let state = (Math.abs(Math.trunc(seed)) % (MODULUS - 1)) + 1;
  const next = () => (state = (state * MULTIPLIER) % MODULUS);
  const total = Math.max(0, Math.min(Math.trunc(density), MAX_SPARKLES));
  const [minSize, sizeRange] = sizes[size] ?? sizes.md;
  return Array.from({ length: total }, () => {
    const px = `${minSize + (next() % sizeRange)}px`;
    const dot = variant === "field" && next() % 3 === 0;
    if (variant === "burst") {
      const style = {
        width: px,
        height: px,
        animationDelay: `${next() % BURST_DELAY_MS}ms`,
        "--markas-sparkle-x": `${(next() % BURST_X) - BURST_X / 2}px`,
        "--markas-sparkle-y": `${(next() % BURST_Y) - BURST_Y / 2}px`,
      } as CSSProperties;
      return { dot, style };
    }
    const [left, top] = place(variant, next);
    const style = {
      left: `${left}%`,
      top: `${top}%`,
      width: px,
      height: px,
      opacity: ((next() % 5) + 5) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
    return { dot, style };
  });
}

export type SparklesProps = ComponentProps<"div"> & {
  variant?: Variant;
  density?: number;
  size?: keyof typeof sizes;
  color?: keyof typeof colors;
  seed?: number;
};

export function Sparkles({
  variant = "field",
  density = 24,
  size = "md",
  color = "warning",
  seed = 5,
  className,
  children,
  ...props
}: SparklesProps) {
  const key: Variant = variant in variants ? variant : "field";
  return (
    <div {...props} className={cx(base, className)}>
      <style>{keyframes}</style>
      <div
        aria-hidden="true"
        className={cx(layer, colors[color] ?? colors.warning)}
      >
        {makeSparkles(key, density, seed, size).map((item, index) => (
          <svg
            key={index}
            className={cx(sparkle, variants[key])}
            style={item.style}
            viewBox="0 0 24 24"
          >
            {item.dot ? <circle cx="12" cy="12" r="5" /> : <path d={star} />}
          </svg>
        ))}
      </div>
      <div className={content}>{children}</div>
    </div>
  );
}
```

```tsx
import { Button } from "@/components/markas/Button";
import { Sparkles } from "@/components/markas/Sparkles";

<Sparkles
  variant="burst"
  density={32}
  size="lg"
  className="rounded-xl border border-line bg-surface px-6 py-10"
>
  <h2 className="text-xl font-semibold text-ink">Buka semua template</h2>
  <Button>Upgrade sekarang</Button>
</Sparkles>;
```

### Vue

Simpan di `src/components/markas/Sparkles.vue`. Tanpa dependensi tambahan.

```vue
<script setup lang="ts">
import { computed } from "vue";

const base = "group/sparkles relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const sparkle = "absolute -translate-1/2 fill-current";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const twinkle =
  "animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none";
const variants = {
  field: twinkle,
  text: twinkle,
  burst:
    "top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]",
};
/** Ukuran terkecil dan rentang tambahan dalam piksel. */
const sizes = { sm: [4, 4], md: [6, 6], lg: [10, 8] } as const;
const star =
  "M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z";
const keyframes =
  "@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}";

/** Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan kilau yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_SPARKLES = 120;
const BURST_X = 240;
const BURST_Y = 140;
const BURST_DELAY_MS = 600;
const EDGE = 1500;

type Variant = keyof typeof variants;

/** Posisi dalam persen: acak di seluruh area (field), atau di pita tepi atas, bawah, kiri, kanan (text). */
function place(variant: Variant, next: () => number) {
  if (variant === "field")
    return [(next() % 10000) / 100, (next() % 10000) / 100];
  const side = next() % 4;
  const along = (next() % 10000) / 100;
  const near = (next() % EDGE) / 100;
  const far = (10000 - (next() % EDGE)) / 100;
  return [[along, along, near, far][side], [near, far, along, along][side]];
}

function makeSparkles(
  variant: Variant,
  density: number,
  seed: number,
  size: keyof typeof sizes,
) {
  let state = (Math.abs(Math.trunc(seed)) % (MODULUS - 1)) + 1;
  const next = () => (state = (state * MULTIPLIER) % MODULUS);
  const total = Math.max(0, Math.min(Math.trunc(density), MAX_SPARKLES));
  const [minSize, sizeRange] = sizes[size] ?? sizes.md;
  return Array.from({ length: total }, () => {
    const px = `${minSize + (next() % sizeRange)}px`;
    const dot = variant === "field" && next() % 3 === 0;
    if (variant === "burst") {
      const style = {
        width: px,
        height: px,
        animationDelay: `${next() % BURST_DELAY_MS}ms`,
        "--markas-sparkle-x": `${(next() % BURST_X) - BURST_X / 2}px`,
        "--markas-sparkle-y": `${(next() % BURST_Y) - BURST_Y / 2}px`,
      };
      return { dot, style };
    }
    const [left, top] = place(variant, next);
    const style = {
      left: `${left}%`,
      top: `${top}%`,
      width: px,
      height: px,
      opacity: ((next() % 5) + 5) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
    return { dot, style };
  });
}

const props = withDefaults(
  defineProps<{
    variant?: Variant;
    density?: number;
    size?: keyof typeof sizes;
    color?: keyof typeof colors;
    seed?: number;
  }>(),
  { variant: "field", density: 24, size: "md", color: "warning", seed: 5 },
);

const key = computed<Variant>(() =>
  props.variant in variants ? props.variant : "field",
);
const items = computed(() =>
  makeSparkles(key.value, props.density, props.seed, props.size),
);
</script>

<template>
  <div :class="base">
    <component :is="'style'">{{ keyframes }}</component>
    <div
      aria-hidden="true"
      :class="[layer, colors[props.color] ?? colors.warning]"
    >
      <svg
        v-for="(item, index) in items"
        :key="index"
        :class="[sparkle, variants[key]]"
        :style="item.style"
        viewBox="0 0 24 24"
      >
        <circle v-if="item.dot" cx="12" cy="12" r="5" />
        <path v-else :d="star" />
      </svg>
    </div>
    <div :class="content"><slot /></div>
  </div>
</template>
```

```vue
<template>
  <Sparkles
    variant="burst"
    :density="32"
    size="lg"
    class="rounded-xl border border-line bg-surface px-6 py-10"
  >
    <h2 class="text-xl font-semibold text-ink">Buka semua template</h2>
    <Button>Upgrade sekarang</Button>
  </Sparkles>
</template>
```

### Svelte

Simpan di `src/lib/components/markas/Sparkles.svelte`. Tanpa dependensi tambahan.

```svelte
<script lang="ts">
  import type { Snippet } from "svelte";
  import type { HTMLAttributes } from "svelte/elements";

  const base = "group/sparkles relative isolate overflow-hidden";
  const layer = "pointer-events-none absolute inset-0";
  const sparkle = "absolute -translate-1/2 fill-current";
  const content = "relative";
  const colors = {
    muted: "text-muted",
    ink: "text-ink",
    primary: "text-primary",
    success: "text-success",
    warning: "text-warning",
    danger: "text-danger",
  };
  const twinkle =
    "animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none";
  const variants = {
    field: twinkle,
    text: twinkle,
    burst:
      "top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]",
  };
  /** Smallest size and extra range in pixels. */
  const sizes = { sm: [4, 4], md: [6, 6], lg: [10, 8] } as const;
  const star =
    "M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z";
  const keyframes =
    "@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}";

  /** Park-Miller: integer math only, so every framework draws the same sparkles. */
  const MODULUS = 2147483647;
  const MULTIPLIER = 48271;
  const MAX_SPARKLES = 120;
  const BURST_X = 240;
  const BURST_Y = 140;
  const BURST_DELAY_MS = 600;
  const EDGE = 1500;

  type Variant = keyof typeof variants;

  /** Position in percent: anywhere in the area (field), or in a band along the top, bottom, left, or right edge (text). */
  function place(variant: Variant, next: () => number) {
    if (variant === "field")
      return [(next() % 10000) / 100, (next() % 10000) / 100];
    const side = next() % 4;
    const along = (next() % 10000) / 100;
    const near = (next() % EDGE) / 100;
    const far = (10000 - (next() % EDGE)) / 100;
    return [[along, along, near, far][side], [near, far, along, along][side]];
  }

  function makeSparkles(
    variant: Variant,
    density: number,
    seed: number,
    size: keyof typeof sizes,
  ) {
    let state = (Math.abs(Math.trunc(seed)) % (MODULUS - 1)) + 1;
    const next = () => (state = (state * MULTIPLIER) % MODULUS);
    const total = Math.max(0, Math.min(Math.trunc(density), MAX_SPARKLES));
    const [minSize, sizeRange] = sizes[size] ?? sizes.md;
    return Array.from({ length: total }, () => {
      const px = `${minSize + (next() % sizeRange)}px`;
      const dot = variant === "field" && next() % 3 === 0;
      if (variant === "burst") {
        const delay = next() % BURST_DELAY_MS;
        const x = (next() % BURST_X) - BURST_X / 2;
        const y = (next() % BURST_Y) - BURST_Y / 2;
        const style = `width: ${px}; height: ${px}; animation-delay: ${delay}ms; --markas-sparkle-x: ${x}px; --markas-sparkle-y: ${y}px`;
        return { dot, style };
      }
      const [left, top] = place(variant, next);
      const opacity = ((next() % 5) + 5) / 10;
      const delay = (next() % 30) * 100;
      const duration = (next() % 3) + 2;
      const style = `left: ${left}%; top: ${top}%; width: ${px}; height: ${px}; opacity: ${opacity}; animation-delay: ${delay}ms; animation-duration: ${duration}s`;
      return { dot, style };
    });
  }

  type Props = HTMLAttributes<HTMLDivElement> & {
    variant?: Variant;
    density?: number;
    size?: keyof typeof sizes;
    color?: keyof typeof colors;
    seed?: number;
    children?: Snippet;
  };

  let {
    variant = "field",
    density = 24,
    size = "md",
    color = "warning",
    seed = 5,
    class: className,
    children,
    ...rest
  }: Props = $props();

  const key = $derived<Variant>(variant in variants ? variant : "field");
  const items = $derived(makeSparkles(key, density, seed, size));
</script>

<div {...rest} class={[base, className]}>
  {@html `<style>${keyframes}</style>`}
  <div aria-hidden="true" class={[layer, colors[color] ?? colors.warning]}>
    {#each items as item, index (index)}
      <svg
        class={[sparkle, variants[key]]}
        style={item.style}
        viewBox="0 0 24 24"
      >
        {#if item.dot}<circle cx="12" cy="12" r="5" />{:else}<path
            d={star}
          />{/if}
      </svg>
    {/each}
  </div>
  <div class={content}>{@render children?.()}</div>
</div>
```

```svelte
<script lang="ts">
  import Button from "$lib/components/markas/Button.svelte";
  import Sparkles from "$lib/components/markas/Sparkles.svelte";
</script>

<Sparkles
  variant="burst"
  density={32}
  size="lg"
  class="rounded-xl border border-line bg-surface px-6 py-10"
>
  <h2 class="text-xl font-semibold text-ink">Unlock every template</h2>
  <Button>Upgrade now</Button>
</Sparkles>
```

### Astro

Simpan di `src/components/markas/Sparkles.astro`. Tanpa dependensi tambahan.

```astro
---
import type { HTMLAttributes } from "astro/types";

const base = "group/sparkles relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const sparkle = "absolute -translate-1/2 fill-current";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const twinkle =
  "animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none";
const variants = {
  field: twinkle,
  text: twinkle,
  burst:
    "top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]",
};
/** Smallest size and extra range in pixels. */
const sizes = { sm: [4, 4], md: [6, 6], lg: [10, 8] } as const;
const star =
  "M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z";
const keyframes =
  "@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}";

/** Park-Miller: integer math only, so every framework draws the same sparkles. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_SPARKLES = 120;
const BURST_X = 240;
const BURST_Y = 140;
const BURST_DELAY_MS = 600;
const EDGE = 1500;

type Variant = keyof typeof variants;

/** Position in percent: anywhere in the area (field), or in a band along the top, bottom, left, or right edge (text). */
function place(variant: Variant, next: () => number) {
  if (variant === "field")
    return [(next() % 10000) / 100, (next() % 10000) / 100];
  const side = next() % 4;
  const along = (next() % 10000) / 100;
  const near = (next() % EDGE) / 100;
  const far = (10000 - (next() % EDGE)) / 100;
  return [[along, along, near, far][side], [near, far, along, along][side]];
}

function makeSparkles(
  variant: Variant,
  density: number,
  seed: number,
  size: keyof typeof sizes,
) {
  let state = (Math.abs(Math.trunc(seed)) % (MODULUS - 1)) + 1;
  const next = () => (state = (state * MULTIPLIER) % MODULUS);
  const total = Math.max(0, Math.min(Math.trunc(density), MAX_SPARKLES));
  const [minSize, sizeRange] = sizes[size] ?? sizes.md;
  return Array.from({ length: total }, () => {
    const px = `${minSize + (next() % sizeRange)}px`;
    const dot = variant === "field" && next() % 3 === 0;
    if (variant === "burst") {
      const style = {
        width: px,
        height: px,
        animationDelay: `${next() % BURST_DELAY_MS}ms`,
        "--markas-sparkle-x": `${(next() % BURST_X) - BURST_X / 2}px`,
        "--markas-sparkle-y": `${(next() % BURST_Y) - BURST_Y / 2}px`,
      };
      return { dot, style };
    }
    const [left, top] = place(variant, next);
    const style = {
      left: `${left}%`,
      top: `${top}%`,
      width: px,
      height: px,
      opacity: ((next() % 5) + 5) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
    return { dot, style };
  });
}

type Props = HTMLAttributes<"div"> & {
  variant?: Variant;
  density?: number;
  size?: keyof typeof sizes;
  color?: keyof typeof colors;
  seed?: number;
};

const {
  variant = "field",
  density = 24,
  size = "md",
  color = "warning",
  seed = 5,
  class: className,
  ...rest
} = Astro.props;
const key: Variant = variant in variants ? variant : "field";
---

<div {...rest} class:list={[base, className]}>
  <style is:inline set:html={keyframes} />
  <div aria-hidden="true" class:list={[layer, colors[color] ?? colors.warning]}>
    {
      makeSparkles(key, density, seed, size).map((item) => (
        <svg
          class:list={[sparkle, variants[key]]}
          style={item.style}
          viewBox="0 0 24 24"
        >
          {item.dot ? <circle cx="12" cy="12" r="5" /> : <path d={star} />}
        </svg>
      ))
    }
  </div>
  <div class={content}><slot /></div>
</div>
```

```astro
---
import Button from "@/components/markas/Button.astro";
import Sparkles from "@/components/markas/Sparkles.astro";
---

<Sparkles
  variant="burst"
  density={32}
  size="lg"
  class="rounded-xl border border-line bg-surface px-6 py-10"
>
  <h2 class="text-xl font-semibold text-ink">Unlock every template</h2>
  <Button>Upgrade now</Button>
</Sparkles>
```

### Angular

Simpan di `src/app/markas/sparkles.component.ts`. Tanpa dependensi tambahan.

```ts
import {
  ChangeDetectionStrategy,
  Component,
  computed,
  input,
  numberAttribute,
  ViewEncapsulation,
} from "@angular/core";

const base = "group/sparkles relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const sparkle = "absolute -translate-1/2 fill-current";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const twinkle =
  "animate-[markas-sparkle_3s_ease-in-out_infinite] motion-reduce:animate-none";
const variants = {
  field: twinkle,
  text: twinkle,
  burst:
    "top-1/2 left-1/2 opacity-0 motion-safe:group-focus-within/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite] motion-safe:group-hover/sparkles:animate-[markas-sparkle-burst_1.2s_ease-out_infinite]",
};
/** Smallest size and extra range in pixels. */
const sizes = { sm: [4, 4], md: [6, 6], lg: [10, 8] } as const;
const star =
  "M12 0C12.6 6.6 17.4 11.4 24 12C17.4 12.6 12.6 17.4 12 24C11.4 17.4 6.6 12.6 0 12C6.6 11.4 11.4 6.6 12 0Z";
const keyframes =
  "@keyframes markas-sparkle{0%,to{opacity:0;transform:scale(.3)}50%{opacity:1;transform:scale(1) rotate(45deg)}}@keyframes markas-sparkle-burst{0%{opacity:0;transform:translate(0,0) scale(.3)}30%{opacity:1}to{opacity:0;transform:translate(var(--markas-sparkle-x),var(--markas-sparkle-y)) scale(1) rotate(90deg)}}";

/** Park-Miller: integer math only, so every framework draws the same sparkles. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_SPARKLES = 120;
const BURST_X = 240;
const BURST_Y = 140;
const BURST_DELAY_MS = 600;
const EDGE = 1500;

export type SparklesVariant = keyof typeof variants;
export type SparklesSize = keyof typeof sizes;
export type SparklesColor = keyof typeof colors;

/** Position in percent: anywhere in the area (field), or in a band along the top, bottom, left, or right edge (text). */
function place(variant: SparklesVariant, next: () => number) {
  if (variant === "field")
    return [(next() % 10000) / 100, (next() % 10000) / 100];
  const side = next() % 4;
  const along = (next() % 10000) / 100;
  const near = (next() % EDGE) / 100;
  const far = (10000 - (next() % EDGE)) / 100;
  return [[along, along, near, far][side], [near, far, along, along][side]];
}

function makeSparkles(
  variant: SparklesVariant,
  density: number,
  seed: number,
  size: SparklesSize,
) {
  let state = (Math.abs(Math.trunc(seed)) % (MODULUS - 1)) + 1;
  const next = () => (state = (state * MULTIPLIER) % MODULUS);
  const total = Math.max(0, Math.min(Math.trunc(density), MAX_SPARKLES));
  const [minSize, sizeRange] = sizes[size] ?? sizes.md;
  return Array.from({ length: total }, () => {
    const px = `${minSize + (next() % sizeRange)}px`;
    const dot = variant === "field" && next() % 3 === 0;
    if (variant === "burst") {
      const delay = next() % BURST_DELAY_MS;
      const x = (next() % BURST_X) - BURST_X / 2;
      const y = (next() % BURST_Y) - BURST_Y / 2;
      const style = `width: ${px}; height: ${px}; animation-delay: ${delay}ms; --markas-sparkle-x: ${x}px; --markas-sparkle-y: ${y}px`;
      return { dot, style };
    }
    const [left, top] = place(variant, next);
    const opacity = ((next() % 5) + 5) / 10;
    const delay = (next() % 30) * 100;
    const duration = (next() % 3) + 2;
    const style = `left: ${left}%; top: ${top}%; width: ${px}; height: ${px}; opacity: ${opacity}; animation-delay: ${delay}ms; animation-duration: ${duration}s`;
    return { dot, style };
  });
}

/**
 * Attribute selector on the native root div: the user's class and attributes stay on it.
 * The keyframes are a global style, so encapsulation is off.
 */
@Component({
  selector: "div[markas-sparkles]",
  changeDetection: ChangeDetectionStrategy.OnPush,
  encapsulation: ViewEncapsulation.None,
  styles: [keyframes],
  host: { "[class]": "base" },
  template: `
    <div aria-hidden="true" [class]="layerClasses()">
      @for (item of items(); track $index) {
        <svg
          [attr.class]="sparkleClasses()"
          [style]="item.style"
          viewBox="0 0 24 24"
        >
          @if (item.dot) {
            <circle cx="12" cy="12" r="5" />
          } @else {
            <path [attr.d]="star" />
          }
        </svg>
      }
    </div>
    <div [class]="content"><ng-content /></div>
  `,
})
export class Sparkles {
  readonly variant = input<SparklesVariant>("field");
  readonly density = input(24, { transform: numberAttribute });
  readonly size = input<SparklesSize>("md");
  readonly color = input<SparklesColor>("warning");
  readonly seed = input(5, { transform: numberAttribute });

  protected readonly base = base;
  protected readonly star = star;
  protected readonly content = content;
  private readonly key = computed<SparklesVariant>(() =>
    this.variant() in variants ? this.variant() : "field",
  );
  protected readonly layerClasses = computed(
    () => `${layer} ${colors[this.color()] ?? colors.warning}`,
  );
  protected readonly sparkleClasses = computed(
    () => `${sparkle} ${variants[this.key()]}`,
  );
  protected readonly items = computed(() =>
    makeSparkles(this.key(), this.density(), this.seed(), this.size()),
  );
}
```

```ts
import { Component } from "@angular/core";
import { Button } from "./markas/button.component";
import { Sparkles } from "./markas/sparkles.component";

@Component({
  selector: "app-upgrade",
  imports: [Button, Sparkles],
  template: `
    <div
      markas-sparkles
      variant="burst"
      density="32"
      size="lg"
      class="rounded-xl border border-line bg-surface px-6 py-10"
    >
      <h2 class="text-xl font-semibold text-ink">Unlock every template</h2>
      <button markas-button>Upgrade now</button>
    </div>
  `,
})
export class Upgrade {}
```

Angular memakai attribute selector pada div native, jadi `class`, `aria-*`, dan atribut lain tetap di elemen akar.

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `variant` | `field \| text \| burst` | field | field: bintang dan titik di seluruh area. text: bintang di sepanjang tepi sekitar judul. burst: bintang memancar dari tengah saat hover atau fokus. |
| `density` | `number` | 24 | Jumlah kilau, maksimal 120. |
| `size` | `sm \| md \| lg` | md | Rentang ukuran kilau: 4 sampai 7px, 6 sampai 11px, atau 10 sampai 17px. |
| `color` | `muted \| ink \| primary \| success \| warning \| danger` | warning | Warna token kilau. |
| `seed` | `number` | 5 | Bilangan bulat yang menentukan posisi, ukuran, dan waktu. Seed sama selalu menghasilkan kilau yang sama. |
| `children / slot` | `slot / ReactNode` | - | Konten yang tampil di atas kilau. |

## Aksesibilitas

- Lapisan kilau memakai aria-hidden dan mengabaikan pointer.
- Dengan reduced motion, kilau field dan text diam, dan kilau burst tetap tersembunyi.
- Burst juga berjalan saat kontrol di dalamnya mendapat fokus keyboard, bukan hanya saat hover.

## Catatan

- Posisi, ukuran, dan waktu dihitung dari `seed` dengan bilangan bulat, jadi semua framework merender kilau yang sama.
- `burst` memakai grup hover dan focus-within CSS pada komponen, jadi tanpa JavaScript dan juga berjalan untuk pengguna keyboard.
- Dengan reduced motion, kilau field dan text diam, dan kilau burst tetap tersembunyi.
- Komponen ini tidak punya teks bawaan, jadi tidak ada prop label yang perlu diterjemahkan.
