# Meteors

Meteor diagonal dengan ekor gradien memudar yang melintas di kartu atau section, posisinya dari seed tetap.

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

## Kapan dipakai

Aksen hidup di dalam kartu fitur, paket harga, section statistik, atau halaman 404.

- Pakai comet untuk kartu kecil dan rain untuk section lebar
- Jaga count di bawah 30 supaya konten tetap jadi fokus
- Ganti seed untuk tata letak lain yang tetap stabil

## Kode

### Blade

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

```blade
@props([
    'variant' => 'rain',
    'count' => null,
    'angle' => 35,
    'speed' => 'normal',
    'color' => 'primary',
    'seed' => 3,
])

@php
    $base = 'relative isolate overflow-hidden';
    $layer = 'pointer-events-none absolute inset-0';
    $meteor = 'absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent';
    $content = 'relative';
    $colors = [
        'muted' => 'text-muted',
        'ink' => 'text-ink',
        'primary' => 'text-primary',
        'success' => 'text-success',
        'warning' => 'text-warning',
        'danger' => 'text-danger',
    ];
    $variants = [
        'rain' => ['meteor' => 'size-px before:h-px', 'count' => 20, 'tail' => [40, 60]],
        'comet' => ['meteor' => 'size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5', 'count' => 6, 'tail' => [100, 80]],
    ];
    // Durasi minimum dan rentang tambahan dalam detik.
    $speeds = ['slow' => [9, 6], 'normal' => [5, 4], 'fast' => [2, 3]];
    $keyframes = '@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}';

    // Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan meteor yang sama.
    $modulus = 2147483647;
    $multiplier = 48271;
    $maxMeteors = 60;
    $maxAngle = 180;

    $key = array_key_exists($variant, $variants) ? $variant : 'rain';
    $turn = 180 + max(0, min((int) $angle, $maxAngle));
    [$minTail, $tailRange] = $variants[$key]['tail'];
    [$minSeconds, $secondsRange] = $speeds[$speed] ?? $speeds['normal'];

    $state = abs((int) $seed) % ($modulus - 1) + 1;
    $next = function () use (&$state, $modulus, $multiplier) {
        return $state = ($state * $multiplier) % $modulus;
    };
    $meteors = [];
    $total = max(0, min((int) ($count ?? $variants[$key]['count']), $maxMeteors));
    for ($i = 0; $i < $total; $i++) {
        $seconds = $minSeconds + $next() % $secondsRange;
        $meteors[] = 'left: '.($next() % 100).'%; top: '.($next() % 70 - 10).'%; opacity: '.((($next() % 5) + 5) / 10).'; animation-duration: '.$seconds.'s; animation-delay: '.(-($next() % ($seconds * 10)) * 100).'ms; --markas-meteor-tail: '.($minTail + $next() % $tailRange).'px';
    }
@endphp

<div {{ $attributes->class([$base]) }}>
    <style>{!! $keyframes !!}</style>
    <div aria-hidden="true" wire:ignore @class([$layer, $colors[$color] ?? $colors['primary']]) style="--markas-meteor-angle: {{ $turn }}deg">
        @foreach ($meteors as $style)
            <span class="{{ $meteor }} {{ $variants[$key]['meteor'] }}" style="{{ $style }}"></span>
        @endforeach
    </div>
    <div class="{{ $content }}">{{ $slot }}</div>
</div>
```

```blade
<x-markas.meteors variant="rain" :count="20" :angle="35" class="rounded-xl border border-line bg-surface px-6 py-12">
    <h2 class="text-2xl font-semibold text-ink">Sejuta event per detik</h2>
    <x-markas.button>Lihat benchmark</x-markas.button>
</x-markas.meteors>
```

Tidak butuh JavaScript atau Alpine.js.

### React

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

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

const base = "relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const meteor =
  "absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  rain: { meteor: "size-px before:h-px", count: 20, tail: [40, 60] as const },
  comet: {
    meteor: "size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5",
    count: 6,
    tail: [100, 80] as const,
  },
};
/** Durasi minimum dan rentang tambahan dalam detik. */
const speeds = { slow: [9, 6], normal: [5, 4], fast: [2, 3] } as const;
const keyframes =
  "@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}";
const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");

/** Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan meteor yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_METEORS = 60;
const MAX_ANGLE = 180;

type Variant = keyof typeof variants;

function makeMeteors(
  variant: Variant,
  count: number,
  seed: number,
  speed: keyof typeof speeds,
) {
  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(count), MAX_METEORS));
  const [minTail, tailRange] = variants[variant].tail;
  const [minSeconds, secondsRange] = speeds[speed] ?? speeds.normal;
  return Array.from({ length: total }, () => {
    const seconds = minSeconds + (next() % secondsRange);
    return {
      left: `${next() % 100}%`,
      top: `${(next() % 70) - 10}%`,
      opacity: ((next() % 5) + 5) / 10,
      animationDuration: `${seconds}s`,
      animationDelay: `${-(next() % (seconds * 10)) * 100}ms`,
      "--markas-meteor-tail": `${minTail + (next() % tailRange)}px`,
    } as CSSProperties;
  });
}

export type MeteorsProps = ComponentProps<"div"> & {
  variant?: Variant;
  count?: number;
  angle?: number;
  speed?: keyof typeof speeds;
  color?: keyof typeof colors;
  seed?: number;
};

export function Meteors({
  variant = "rain",
  count,
  angle = 35,
  speed = "normal",
  color = "primary",
  seed = 3,
  className,
  children,
  ...props
}: MeteorsProps) {
  const key: Variant = variant in variants ? variant : "rain";
  const turn = 180 + Math.max(0, Math.min(Math.trunc(angle), MAX_ANGLE));
  return (
    <div {...props} className={cx(base, className)}>
      <style>{keyframes}</style>
      <div
        aria-hidden="true"
        className={cx(layer, colors[color] ?? colors.primary)}
        style={{ "--markas-meteor-angle": `${turn}deg` } as CSSProperties}
      >
        {makeMeteors(key, count ?? variants[key].count, seed, speed).map(
          (item, index) => (
            <span
              key={index}
              className={cx(meteor, variants[key].meteor)}
              style={item}
            />
          ),
        )}
      </div>
      <div className={content}>{children}</div>
    </div>
  );
}
```

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

<Meteors
  variant="rain"
  count={20}
  angle={35}
  className="rounded-xl border border-line bg-surface px-6 py-12"
>
  <h2 className="text-2xl font-semibold text-ink">Sejuta event per detik</h2>
  <Button>Lihat benchmark</Button>
</Meteors>;
```

### Vue

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

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

const base = "relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const meteor =
  "absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  rain: { meteor: "size-px before:h-px", count: 20, tail: [40, 60] as const },
  comet: {
    meteor: "size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5",
    count: 6,
    tail: [100, 80] as const,
  },
};
/** Durasi minimum dan rentang tambahan dalam detik. */
const speeds = { slow: [9, 6], normal: [5, 4], fast: [2, 3] } as const;
const keyframes =
  "@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}";

/** Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan meteor yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_METEORS = 60;
const MAX_ANGLE = 180;

type Variant = keyof typeof variants;

function makeMeteors(
  variant: Variant,
  count: number,
  seed: number,
  speed: keyof typeof speeds,
) {
  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(count), MAX_METEORS));
  const [minTail, tailRange] = variants[variant].tail;
  const [minSeconds, secondsRange] = speeds[speed] ?? speeds.normal;
  return Array.from({ length: total }, () => {
    const seconds = minSeconds + (next() % secondsRange);
    return {
      left: `${next() % 100}%`,
      top: `${(next() % 70) - 10}%`,
      opacity: ((next() % 5) + 5) / 10,
      animationDuration: `${seconds}s`,
      animationDelay: `${-(next() % (seconds * 10)) * 100}ms`,
      "--markas-meteor-tail": `${minTail + (next() % tailRange)}px`,
    };
  });
}

const props = withDefaults(
  defineProps<{
    variant?: Variant;
    count?: number;
    angle?: number;
    speed?: keyof typeof speeds;
    color?: keyof typeof colors;
    seed?: number;
  }>(),
  {
    variant: "rain",
    count: undefined,
    angle: 35,
    speed: "normal",
    color: "primary",
    seed: 3,
  },
);

const key = computed<Variant>(() =>
  props.variant in variants ? props.variant : "rain",
);
const turn = computed(
  () => `${180 + Math.max(0, Math.min(Math.trunc(props.angle), MAX_ANGLE))}deg`,
);
const items = computed(() =>
  makeMeteors(
    key.value,
    props.count ?? variants[key.value].count,
    props.seed,
    props.speed,
  ),
);
</script>

<template>
  <div :class="base">
    <component :is="'style'">{{ keyframes }}</component>
    <div
      aria-hidden="true"
      :class="[layer, colors[props.color] ?? colors.primary]"
      :style="{ '--markas-meteor-angle': turn }"
    >
      <span
        v-for="(item, index) in items"
        :key="index"
        :class="[meteor, variants[key].meteor]"
        :style="item"
      />
    </div>
    <div :class="content"><slot /></div>
  </div>
</template>
```

```vue
<template>
  <Meteors
    variant="rain"
    :count="20"
    :angle="35"
    class="rounded-xl border border-line bg-surface px-6 py-12"
  >
    <h2 class="text-2xl font-semibold text-ink">Sejuta event per detik</h2>
    <Button>Lihat benchmark</Button>
  </Meteors>
</template>
```

### Svelte

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

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

  const base = "relative isolate overflow-hidden";
  const layer = "pointer-events-none absolute inset-0";
  const meteor =
    "absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent";
  const content = "relative";
  const colors = {
    muted: "text-muted",
    ink: "text-ink",
    primary: "text-primary",
    success: "text-success",
    warning: "text-warning",
    danger: "text-danger",
  };
  const variants = {
    rain: { meteor: "size-px before:h-px", count: 20, tail: [40, 60] as const },
    comet: {
      meteor: "size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5",
      count: 6,
      tail: [100, 80] as const,
    },
  };
  /** Minimum duration and extra range in seconds. */
  const speeds = { slow: [9, 6], normal: [5, 4], fast: [2, 3] } as const;
  const keyframes =
    "@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}";

  /** Park-Miller: integer math only, so every framework draws the same meteors. */
  const MODULUS = 2147483647;
  const MULTIPLIER = 48271;
  const MAX_METEORS = 60;
  const MAX_ANGLE = 180;

  type Variant = keyof typeof variants;

  function makeMeteors(
    variant: Variant,
    count: number,
    seed: number,
    speed: keyof typeof speeds,
  ) {
    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(count), MAX_METEORS));
    const [minTail, tailRange] = variants[variant].tail;
    const [minSeconds, secondsRange] = speeds[speed] ?? speeds.normal;
    return Array.from({ length: total }, () => {
      const seconds = minSeconds + (next() % secondsRange);
      const left = next() % 100;
      const top = (next() % 70) - 10;
      const opacity = ((next() % 5) + 5) / 10;
      const delay = -(next() % (seconds * 10)) * 100;
      const tail = minTail + (next() % tailRange);
      return `left: ${left}%; top: ${top}%; opacity: ${opacity}; animation-duration: ${seconds}s; animation-delay: ${delay}ms; --markas-meteor-tail: ${tail}px`;
    });
  }

  type Props = HTMLAttributes<HTMLDivElement> & {
    variant?: Variant;
    count?: number;
    angle?: number;
    speed?: keyof typeof speeds;
    color?: keyof typeof colors;
    seed?: number;
    children?: Snippet;
  };

  let {
    variant = "rain",
    count,
    angle = 35,
    speed = "normal",
    color = "primary",
    seed = 3,
    class: className,
    children,
    ...rest
  }: Props = $props();

  const key = $derived<Variant>(variant in variants ? variant : "rain");
  const turn = $derived(
    180 + Math.max(0, Math.min(Math.trunc(angle), MAX_ANGLE)),
  );
  const items = $derived(
    makeMeteors(key, count ?? variants[key].count, seed, speed),
  );
</script>

<div {...rest} class={[base, className]}>
  {@html `<style>${keyframes}</style>`}
  <div
    aria-hidden="true"
    class={[layer, colors[color] ?? colors.primary]}
    style="--markas-meteor-angle: {turn}deg"
  >
    {#each items as style, index (index)}
      <span class={[meteor, variants[key].meteor]} {style}></span>
    {/each}
  </div>
  <div class={content}>{@render children?.()}</div>
</div>
```

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

<Meteors
  variant="rain"
  count={20}
  angle={35}
  class="rounded-xl border border-line bg-surface px-6 py-12"
>
  <h2 class="text-2xl font-semibold text-ink">A million events a second</h2>
  <Button>View benchmarks</Button>
</Meteors>
```

### Astro

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

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

const base = "relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const meteor =
  "absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  rain: { meteor: "size-px before:h-px", count: 20, tail: [40, 60] as const },
  comet: {
    meteor: "size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5",
    count: 6,
    tail: [100, 80] as const,
  },
};
/** Minimum duration and extra range in seconds. */
const speeds = { slow: [9, 6], normal: [5, 4], fast: [2, 3] } as const;
const keyframes =
  "@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}";

/** Park-Miller: integer math only, so every framework draws the same meteors. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_METEORS = 60;
const MAX_ANGLE = 180;

type Variant = keyof typeof variants;

function makeMeteors(
  variant: Variant,
  count: number,
  seed: number,
  speed: keyof typeof speeds,
) {
  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(count), MAX_METEORS));
  const [minTail, tailRange] = variants[variant].tail;
  const [minSeconds, secondsRange] = speeds[speed] ?? speeds.normal;
  return Array.from({ length: total }, () => {
    const seconds = minSeconds + (next() % secondsRange);
    return {
      left: `${next() % 100}%`,
      top: `${(next() % 70) - 10}%`,
      opacity: ((next() % 5) + 5) / 10,
      animationDuration: `${seconds}s`,
      animationDelay: `${-(next() % (seconds * 10)) * 100}ms`,
      "--markas-meteor-tail": `${minTail + (next() % tailRange)}px`,
    };
  });
}

type Props = HTMLAttributes<"div"> & {
  variant?: Variant;
  count?: number;
  angle?: number;
  speed?: keyof typeof speeds;
  color?: keyof typeof colors;
  seed?: number;
};

const {
  variant = "rain",
  count,
  angle = 35,
  speed = "normal",
  color = "primary",
  seed = 3,
  class: className,
  ...rest
} = Astro.props;
const key: Variant = variant in variants ? variant : "rain";
const turn = 180 + Math.max(0, Math.min(Math.trunc(angle), MAX_ANGLE));
const items = makeMeteors(key, count ?? variants[key].count, seed, speed);
---

<div {...rest} class:list={[base, className]}>
  <style is:inline set:html={keyframes} />
  <div
    aria-hidden="true"
    class:list={[layer, colors[color] ?? colors.primary]}
    style={{ "--markas-meteor-angle": `${turn}deg` }}
  >
    {items.map((style) => <span class:list={[meteor, variants[key].meteor]} style={style} />)}
  </div>
  <div class={content}><slot /></div>
</div>
```

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

<Meteors
  variant="rain"
  count={20}
  angle={35}
  class="rounded-xl border border-line bg-surface px-6 py-12"
>
  <h2 class="text-2xl font-semibold text-ink">A million events a second</h2>
  <Button>View benchmarks</Button>
</Meteors>
```

### Angular

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

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

const base = "relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const meteor =
  "absolute rounded-full bg-current [transform:rotate(var(--markas-meteor-angle))] animate-[markas-meteor_6s_linear_infinite] motion-reduce:animate-none before:absolute before:top-1/2 before:left-1/2 before:w-(--markas-meteor-tail) before:-translate-y-1/2 before:rounded-full before:bg-linear-to-r before:from-current before:to-transparent";
const content = "relative";
const colors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  rain: { meteor: "size-px before:h-px", count: 20, tail: [40, 60] as const },
  comet: {
    meteor: "size-1 shadow-[0_0_8px_2px_currentColor] before:h-0.5",
    count: 6,
    tail: [100, 80] as const,
  },
};
/** Minimum duration and extra range in seconds. */
const speeds = { slow: [9, 6], normal: [5, 4], fast: [2, 3] } as const;
const keyframes =
  "@keyframes markas-meteor{0%{transform:rotate(var(--markas-meteor-angle)) translateX(0);opacity:1}70%{opacity:1}to{transform:rotate(var(--markas-meteor-angle)) translateX(-640px);opacity:0}}";

/** Park-Miller: integer math only, so every framework draws the same meteors. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_METEORS = 60;
const MAX_ANGLE = 180;

export type MeteorsVariant = keyof typeof variants;
export type MeteorsSpeed = keyof typeof speeds;
export type MeteorsColor = keyof typeof colors;

function makeMeteors(
  variant: MeteorsVariant,
  count: number,
  seed: number,
  speed: MeteorsSpeed,
) {
  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(count), MAX_METEORS));
  const [minTail, tailRange] = variants[variant].tail;
  const [minSeconds, secondsRange] = speeds[speed] ?? speeds.normal;
  return Array.from({ length: total }, () => {
    const seconds = minSeconds + (next() % secondsRange);
    const left = next() % 100;
    const top = (next() % 70) - 10;
    const opacity = ((next() % 5) + 5) / 10;
    const delay = -(next() % (seconds * 10)) * 100;
    const tail = minTail + (next() % tailRange);
    return `left: ${left}%; top: ${top}%; opacity: ${opacity}; animation-duration: ${seconds}s; animation-delay: ${delay}ms; --markas-meteor-tail: ${tail}px`;
  });
}

/** Empty attribute or no value: undefined, so the variant picks its own count. */
const optionalNumber = (value: unknown) =>
  value == null || value === "" ? undefined : numberAttribute(value);

/**
 * 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-meteors]",
  changeDetection: ChangeDetectionStrategy.OnPush,
  encapsulation: ViewEncapsulation.None,
  styles: [keyframes],
  host: { "[class]": "base" },
  template: `
    <div
      aria-hidden="true"
      [class]="layerClasses()"
      [style.--markas-meteor-angle]="turn()"
    >
      @for (style of items(); track $index) {
        <span [class]="meteorClasses()" [style]="style"></span>
      }
    </div>
    <div [class]="content"><ng-content /></div>
  `,
})
export class Meteors {
  readonly variant = input<MeteorsVariant>("rain");
  readonly count = input<number | undefined, unknown>(undefined, {
    transform: optionalNumber,
  });
  readonly angle = input(35, { transform: numberAttribute });
  readonly speed = input<MeteorsSpeed>("normal");
  readonly color = input<MeteorsColor>("primary");
  readonly seed = input(3, { transform: numberAttribute });

  protected readonly base = base;
  protected readonly content = content;
  private readonly key = computed<MeteorsVariant>(() =>
    this.variant() in variants ? this.variant() : "rain",
  );
  protected readonly turn = computed(
    () =>
      `${180 + Math.max(0, Math.min(Math.trunc(this.angle()), MAX_ANGLE))}deg`,
  );
  protected readonly layerClasses = computed(
    () => `${layer} ${colors[this.color()] ?? colors.primary}`,
  );
  protected readonly meteorClasses = computed(
    () => `${meteor} ${variants[this.key()].meteor}`,
  );
  protected readonly items = computed(() =>
    makeMeteors(
      this.key(),
      this.count() ?? variants[this.key()].count,
      this.seed(),
      this.speed(),
    ),
  );
}
```

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

@Component({
  selector: "app-launch",
  imports: [Button, Meteors],
  template: `
    <div
      markas-meteors
      variant="rain"
      count="20"
      angle="35"
      class="rounded-xl border border-line bg-surface px-6 py-12"
    >
      <h2 class="text-2xl font-semibold text-ink">A million events a second</h2>
      <button markas-button>View benchmarks</button>
    </div>
  `,
})
export class Launch {}
```

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

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `variant` | `rain \| comet` | rain | rain: banyak meteor tipis dengan ekor pendek. comet: sedikit meteor tebal bercahaya dengan ekor panjang. |
| `count` | `number` | 20 (rain), 6 (comet) | Jumlah meteor, maksimal 60. |
| `angle` | `number` | 35 | Arah lintasan dalam derajat di bawah horizon, 0 sampai 180. 35 jatuh ke kanan bawah, 90 jatuh lurus ke bawah. |
| `speed` | `slow \| normal \| fast` | normal | Lama setiap meteor melintas. Setiap meteor punya durasi sendiri dalam rentang itu. |
| `color` | `muted \| ink \| primary \| success \| warning \| danger` | primary | Warna token meteor dan ekornya. |
| `seed` | `number` | 3 | Bilangan bulat yang menentukan posisi, ekor, dan waktu. Seed sama selalu menghasilkan hujan meteor yang sama. |
| `children / slot` | `slot / ReactNode` | - | Konten yang tampil di atas meteor. |

## Aksesibilitas

- Lapisan meteor memakai aria-hidden dan mengabaikan pointer.
- Dengan reduced motion, meteor berhenti di titik awal dan tetap terlihat sebagai garis diam.

## Catatan

- Posisi, panjang ekor, dan waktu dihitung dari `seed` dengan bilangan bulat, jadi semua framework merender hujan meteor yang sama.
- Setiap meteor adalah satu elemen dengan ekor gradien dari `::before`, digerakkan dengan transform CSS. Tanpa JavaScript.
- Dengan reduced motion meteor berhenti di titik awalnya.
- Komponen ini tidak punya teks bawaan, jadi tidak ada prop label yang perlu diterjemahkan.
