# Shooting Stars

Bidang bintang berkelip dengan bintang jatuh yang melesat setiap beberapa detik. Langit malam atau fajar hangat, semua dari warna token.

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

## Kapan dipakai

Langit malam atau fajar di belakang waitlist, hero peluncuran, pengumuman acara, atau kartu masuk.

- Tambahkan class dark supaya langit tetap gelap di semua tema
- Pakai dawn dengan ekor warning atau danger untuk halaman bertema pagi yang hangat
- Jaga stars di bawah 150 untuk kartu dan section kecil

## Kode

### Blade

Simpan di `resources/views/components/markas/shooting-stars.blade.php`. Tanpa dependensi tambahan.

```blade
@props([
    'variant' => 'night',
    'frequency' => 'normal',
    'trailColor' => null,
    'stars' => 70,
    'seed' => 11,
])

@php
    $base = 'relative isolate overflow-hidden';
    $layer = 'pointer-events-none absolute inset-0';
    $star = 'absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none';
    $streak = 'absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none';
    $content = 'relative';
    $trailColors = [
        'muted' => 'text-muted',
        'ink' => 'text-ink',
        'primary' => 'text-primary',
        'success' => 'text-success',
        'warning' => 'text-warning',
        'danger' => 'text-danger',
    ];
    $variants = [
        'night' => ['glow' => '', 'trail' => 'primary', 'sky' => 100],
        'dawn' => ['glow' => 'absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent', 'trail' => 'warning', 'sky' => 60],
    ];
    // Satu putaran animasi dalam milidetik; tiga bintang jatuh berbagi putaran, jadi satu muncul tiap sepertiganya.
    $frequencies = ['low' => 15000, 'normal' => 9000, 'high' => 4500];
    $keyframes = '@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);opacity:0}}';

    // Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan langit yang sama.
    $modulus = 2147483647;
    $multiplier = 48271;
    $maxStars = 300;
    $streakCount = 3;
    $jitterMs = 1000;

    $key = array_key_exists($variant, $variants) ? $variant : 'night';
    $config = $variants[$key];
    $trail = $trailColors[$trailColor ?? $config['trail']] ?? $trailColors['primary'];

    $state = abs((int) $seed) % ($modulus - 1) + 1;
    $next = function () use (&$state, $modulus, $multiplier) {
        return $state = ($state * $multiplier) % $modulus;
    };
    $starStyles = [];
    $total = max(0, min((int) $stars, $maxStars));
    for ($i = 0; $i < $total; $i++) {
        $size = $next() % 6 === 0 ? 2 : 1;
        $starStyles[] = 'left: '.(($next() % 10000) / 100).'%; top: '.(($next() % ($config['sky'] * 100)) / 100).'%; width: '.$size.'px; height: '.$size.'px; opacity: '.((($next() % 6) + 3) / 10).'; animation-delay: '.(($next() % 30) * 100).'ms; animation-duration: '.(($next() % 3) + 2).'s';
    }
    $cycle = $frequencies[$frequency] ?? $frequencies['normal'];
    $streakStyles = [];
    for ($i = 0; $i < $streakCount; $i++) {
        $streakStyles[] = 'left: '.(20 + $next() % 60).'%; top: '.($next() % 45).'%; width: '.(80 + $next() % 60).'px; animation-duration: '.$cycle.'ms; animation-delay: '.(-((($streakCount - $i) % $streakCount) * intdiv($cycle, $streakCount) + $next() % $jitterMs)).'ms';
    }
@endphp

<div {{ $attributes->class([$base]) }}>
    <style>{!! $keyframes !!}</style>
    <div aria-hidden="true" wire:ignore @class([$layer, $trail])>
        @if ($config['glow'])
            <div class="{{ $config['glow'] }}"></div>
        @endif
        @foreach ($starStyles as $style)
            <span class="{{ $star }}" style="{{ $style }}"></span>
        @endforeach
        @foreach ($streakStyles as $style)
            <span class="{{ $streak }}" style="{{ $style }}"></span>
        @endforeach
    </div>
    <div class="{{ $content }}">{{ $slot }}</div>
</div>
```

```blade
<x-markas.shooting-stars variant="night" frequency="normal" trail-color="primary" class="dark rounded-xl bg-canvas px-6 py-14">
    <h2 class="text-2xl font-semibold text-ink">Buat permintaan, lalu rilis</h2>
    <x-markas.button>Gabung waitlist</x-markas.button>
</x-markas.shooting-stars>
```

Tidak butuh JavaScript atau Alpine.js.

### React

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

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

const base = "relative isolate overflow-hidden";
const layer = "pointer-events-none absolute inset-0";
const star =
  "absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none";
const streak =
  "absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none";
const content = "relative";
const trailColors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  night: { glow: "", trail: "primary", sky: 100 },
  dawn: {
    glow: "absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent",
    trail: "warning",
    sky: 60,
  },
} as const;
/** Satu putaran animasi dalam milidetik; tiga bintang jatuh berbagi putaran, jadi satu muncul tiap sepertiganya. */
const frequencies = { low: 15000, normal: 9000, high: 4500 };
const keyframes =
  "@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);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 langit yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_STARS = 300;
const STREAKS = 3;
const JITTER_MS = 1000;

type Variant = keyof typeof variants;

function makeSky(
  variant: Variant,
  count: number,
  seed: number,
  frequency: keyof typeof frequencies,
) {
  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_STARS));
  const sky = variants[variant].sky;
  const stars = Array.from({ length: total }, () => {
    const size = next() % 6 === 0 ? 2 : 1;
    return {
      left: `${(next() % 10000) / 100}%`,
      top: `${(next() % (sky * 100)) / 100}%`,
      width: `${size}px`,
      height: `${size}px`,
      opacity: ((next() % 6) + 3) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
  });
  const cycle = frequencies[frequency] ?? frequencies.normal;
  const streaks = Array.from({ length: STREAKS }, (_, i) => ({
    left: `${20 + (next() % 60)}%`,
    top: `${next() % 45}%`,
    width: `${80 + (next() % 60)}px`,
    animationDuration: `${cycle}ms`,
    animationDelay: `${-(((STREAKS - i) % STREAKS) * (cycle / STREAKS) + (next() % JITTER_MS))}ms`,
  }));
  return { stars, streaks };
}

export type ShootingStarsProps = ComponentProps<"div"> & {
  variant?: Variant;
  frequency?: keyof typeof frequencies;
  trailColor?: keyof typeof trailColors;
  stars?: number;
  seed?: number;
};

export function ShootingStars({
  variant = "night",
  frequency = "normal",
  trailColor,
  stars = 70,
  seed = 11,
  className,
  children,
  ...props
}: ShootingStarsProps) {
  const key: Variant = variant in variants ? variant : "night";
  const config = variants[key];
  const sky = makeSky(key, stars, seed, frequency);
  return (
    <div {...props} className={cx(base, className)}>
      <style>{keyframes}</style>
      <div
        aria-hidden="true"
        className={cx(
          layer,
          trailColors[trailColor ?? config.trail] ?? trailColors.primary,
        )}
      >
        {config.glow && <div className={config.glow} />}
        {sky.stars.map((style, index) => (
          <span key={index} className={star} style={style} />
        ))}
        {sky.streaks.map((style, index) => (
          <span key={`s${index}`} className={streak} style={style} />
        ))}
      </div>
      <div className={content}>{children}</div>
    </div>
  );
}
```

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

<ShootingStars
  variant="night"
  frequency="normal"
  trailColor="primary"
  className="dark rounded-xl bg-canvas px-6 py-14"
>
  <h2 className="text-2xl font-semibold text-ink">
    Buat permintaan, lalu rilis
  </h2>
  <Button>Gabung waitlist</Button>
</ShootingStars>;
```

### Vue

Simpan di `src/components/markas/ShootingStars.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 star =
  "absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none";
const streak =
  "absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none";
const content = "relative";
const trailColors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  night: { glow: "", trail: "primary", sky: 100 },
  dawn: {
    glow: "absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent",
    trail: "warning",
    sky: 60,
  },
} as const;
/** Satu putaran animasi dalam milidetik; tiga bintang jatuh berbagi putaran, jadi satu muncul tiap sepertiganya. */
const frequencies = { low: 15000, normal: 9000, high: 4500 };
const keyframes =
  "@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);opacity:0}}";

/** Park-Miller: hanya operasi bilangan bulat, jadi Blade, React, dan Vue menghasilkan langit yang sama. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_STARS = 300;
const STREAKS = 3;
const JITTER_MS = 1000;

type Variant = keyof typeof variants;

function makeSky(
  variant: Variant,
  count: number,
  seed: number,
  frequency: keyof typeof frequencies,
) {
  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_STARS));
  const sky = variants[variant].sky;
  const stars = Array.from({ length: total }, () => {
    const size = next() % 6 === 0 ? 2 : 1;
    return {
      left: `${(next() % 10000) / 100}%`,
      top: `${(next() % (sky * 100)) / 100}%`,
      width: `${size}px`,
      height: `${size}px`,
      opacity: ((next() % 6) + 3) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
  });
  const cycle = frequencies[frequency] ?? frequencies.normal;
  const streaks = Array.from({ length: STREAKS }, (_, i) => ({
    left: `${20 + (next() % 60)}%`,
    top: `${next() % 45}%`,
    width: `${80 + (next() % 60)}px`,
    animationDuration: `${cycle}ms`,
    animationDelay: `${-(((STREAKS - i) % STREAKS) * (cycle / STREAKS) + (next() % JITTER_MS))}ms`,
  }));
  return { stars, streaks };
}

const props = withDefaults(
  defineProps<{
    variant?: Variant;
    frequency?: keyof typeof frequencies;
    trailColor?: keyof typeof trailColors;
    stars?: number;
    seed?: number;
  }>(),
  {
    variant: "night",
    frequency: "normal",
    trailColor: undefined,
    stars: 70,
    seed: 11,
  },
);

const key = computed<Variant>(() =>
  props.variant in variants ? props.variant : "night",
);
const config = computed(() => variants[key.value]);
const sky = computed(() =>
  makeSky(key.value, props.stars, props.seed, props.frequency),
);
const trail = computed(
  () =>
    trailColors[props.trailColor ?? config.value.trail] ?? trailColors.primary,
);
</script>

<template>
  <div :class="base">
    <component :is="'style'">{{ keyframes }}</component>
    <div aria-hidden="true" :class="[layer, trail]">
      <div v-if="config.glow" :class="config.glow" />
      <span
        v-for="(style, index) in sky.stars"
        :key="index"
        :class="star"
        :style="style"
      />
      <span
        v-for="(style, index) in sky.streaks"
        :key="`s${index}`"
        :class="streak"
        :style="style"
      />
    </div>
    <div :class="content"><slot /></div>
  </div>
</template>
```

```vue
<template>
  <ShootingStars
    variant="night"
    frequency="normal"
    trail-color="primary"
    class="dark rounded-xl bg-canvas px-6 py-14"
  >
    <h2 class="text-2xl font-semibold text-ink">Buat permintaan, lalu rilis</h2>
    <Button>Gabung waitlist</Button>
  </ShootingStars>
</template>
```

### Svelte

Simpan di `src/lib/components/markas/ShootingStars.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 star =
    "absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none";
  const streak =
    "absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none";
  const content = "relative";
  const trailColors = {
    muted: "text-muted",
    ink: "text-ink",
    primary: "text-primary",
    success: "text-success",
    warning: "text-warning",
    danger: "text-danger",
  };
  const variants = {
    night: { glow: "", trail: "primary", sky: 100 },
    dawn: {
      glow: "absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent",
      trail: "warning",
      sky: 60,
    },
  } as const;
  /** One animation cycle in milliseconds; three shooting stars share a cycle, so one appears every third of it. */
  const frequencies = { low: 15000, normal: 9000, high: 4500 };
  const keyframes =
    "@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);opacity:0}}";

  /** Park-Miller: integer math only, so every framework draws the same sky. */
  const MODULUS = 2147483647;
  const MULTIPLIER = 48271;
  const MAX_STARS = 300;
  const STREAKS = 3;
  const JITTER_MS = 1000;

  type Variant = keyof typeof variants;

  function makeSky(
    variant: Variant,
    count: number,
    seed: number,
    frequency: keyof typeof frequencies,
  ) {
    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_STARS));
    const sky = variants[variant].sky;
    const stars = Array.from({ length: total }, () => {
      const size = next() % 6 === 0 ? 2 : 1;
      const left = (next() % 10000) / 100;
      const top = (next() % (sky * 100)) / 100;
      const opacity = ((next() % 6) + 3) / 10;
      const delay = (next() % 30) * 100;
      const duration = (next() % 3) + 2;
      return `left: ${left}%; top: ${top}%; width: ${size}px; height: ${size}px; opacity: ${opacity}; animation-delay: ${delay}ms; animation-duration: ${duration}s`;
    });
    const cycle = frequencies[frequency] ?? frequencies.normal;
    const streaks = Array.from({ length: STREAKS }, (_, i) => {
      const left = 20 + (next() % 60);
      const top = next() % 45;
      const width = 80 + (next() % 60);
      const delay = -(
        ((STREAKS - i) % STREAKS) * (cycle / STREAKS) +
        (next() % JITTER_MS)
      );
      return `left: ${left}%; top: ${top}%; width: ${width}px; animation-duration: ${cycle}ms; animation-delay: ${delay}ms`;
    });
    return { stars, streaks };
  }

  type Props = HTMLAttributes<HTMLDivElement> & {
    variant?: Variant;
    frequency?: keyof typeof frequencies;
    trailColor?: keyof typeof trailColors;
    stars?: number;
    seed?: number;
    children?: Snippet;
  };

  let {
    variant = "night",
    frequency = "normal",
    trailColor,
    stars = 70,
    seed = 11,
    class: className,
    children,
    ...rest
  }: Props = $props();

  const key = $derived<Variant>(variant in variants ? variant : "night");
  const config = $derived(variants[key]);
  const sky = $derived(makeSky(key, stars, seed, frequency));
</script>

<div {...rest} class={[base, className]}>
  {@html `<style>${keyframes}</style>`}
  <div
    aria-hidden="true"
    class={[
      layer,
      trailColors[trailColor ?? config.trail] ?? trailColors.primary,
    ]}
  >
    {#if config.glow}<div class={config.glow}></div>{/if}
    {#each sky.stars as style, index (index)}
      <span class={star} {style}></span>
    {/each}
    {#each sky.streaks as style, index (index)}
      <span class={streak} {style}></span>
    {/each}
  </div>
  <div class={content}>{@render children?.()}</div>
</div>
```

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

<ShootingStars
  variant="night"
  frequency="normal"
  trailColor="primary"
  class="dark rounded-xl bg-canvas px-6 py-14"
>
  <h2 class="text-2xl font-semibold text-ink">Make a wish, then ship it</h2>
  <Button>Join the waitlist</Button>
</ShootingStars>
```

### Astro

Simpan di `src/components/markas/ShootingStars.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 star =
  "absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none";
const streak =
  "absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none";
const content = "relative";
const trailColors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  night: { glow: "", trail: "primary", sky: 100 },
  dawn: {
    glow: "absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent",
    trail: "warning",
    sky: 60,
  },
} as const;
/** One animation cycle in milliseconds; three shooting stars share a cycle, so one appears every third of it. */
const frequencies = { low: 15000, normal: 9000, high: 4500 };
const keyframes =
  "@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);opacity:0}}";

/** Park-Miller: integer math only, so every framework draws the same sky. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_STARS = 300;
const STREAKS = 3;
const JITTER_MS = 1000;

type Variant = keyof typeof variants;

function makeSky(
  variant: Variant,
  count: number,
  seed: number,
  frequency: keyof typeof frequencies,
) {
  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_STARS));
  const sky = variants[variant].sky;
  const stars = Array.from({ length: total }, () => {
    const size = next() % 6 === 0 ? 2 : 1;
    return {
      left: `${(next() % 10000) / 100}%`,
      top: `${(next() % (sky * 100)) / 100}%`,
      width: `${size}px`,
      height: `${size}px`,
      opacity: ((next() % 6) + 3) / 10,
      animationDelay: `${(next() % 30) * 100}ms`,
      animationDuration: `${(next() % 3) + 2}s`,
    };
  });
  const cycle = frequencies[frequency] ?? frequencies.normal;
  const streaks = Array.from({ length: STREAKS }, (_, i) => ({
    left: `${20 + (next() % 60)}%`,
    top: `${next() % 45}%`,
    width: `${80 + (next() % 60)}px`,
    animationDuration: `${cycle}ms`,
    animationDelay: `${-(((STREAKS - i) % STREAKS) * (cycle / STREAKS) + (next() % JITTER_MS))}ms`,
  }));
  return { stars, streaks };
}

type Props = HTMLAttributes<"div"> & {
  variant?: Variant;
  frequency?: keyof typeof frequencies;
  trailColor?: keyof typeof trailColors;
  stars?: number;
  seed?: number;
};

const {
  variant = "night",
  frequency = "normal",
  trailColor,
  stars = 70,
  seed = 11,
  class: className,
  ...rest
} = Astro.props;
const key: Variant = variant in variants ? variant : "night";
const config = variants[key];
const sky = makeSky(key, stars, seed, frequency);
---

<div {...rest} class:list={[base, className]}>
  <style is:inline set:html={keyframes} />
  <div
    aria-hidden="true"
    class:list={[
      layer,
      trailColors[trailColor ?? config.trail] ?? trailColors.primary,
    ]}
  >
    {config.glow && <div class={config.glow} />}
    {sky.stars.map((style) => <span class={star} style={style} />)}
    {sky.streaks.map((style) => <span class={streak} style={style} />)}
  </div>
  <div class={content}><slot /></div>
</div>
```

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

<ShootingStars
  variant="night"
  frequency="normal"
  trailColor="primary"
  class="dark rounded-xl bg-canvas px-6 py-14"
>
  <h2 class="text-2xl font-semibold text-ink">Make a wish, then ship it</h2>
  <Button>Join the waitlist</Button>
</ShootingStars>
```

### Angular

Simpan di `src/app/markas/shooting-stars.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 star =
  "absolute rounded-full bg-ink animate-[markas-star-blink_3s_ease-in-out_infinite] motion-reduce:animate-none";
const streak =
  "absolute h-px rounded-full bg-linear-to-r from-ink via-current to-transparent [transform:rotate(215deg)] animate-[markas-shooting-star_9s_ease-out_infinite] motion-reduce:animate-none";
const content = "relative";
const trailColors = {
  muted: "text-muted",
  ink: "text-ink",
  primary: "text-primary",
  success: "text-success",
  warning: "text-warning",
  danger: "text-danger",
};
const variants = {
  night: { glow: "", trail: "primary", sky: 100 },
  dawn: {
    glow: "absolute inset-x-0 bottom-0 h-3/4 bg-linear-to-t from-warning/25 via-danger/5 to-transparent",
    trail: "warning",
    sky: 60,
  },
} as const;
/** One animation cycle in milliseconds; three shooting stars share a cycle, so one appears every third of it. */
const frequencies = { low: 15000, normal: 9000, high: 4500 };
const keyframes =
  "@keyframes markas-star-blink{50%{opacity:.2}}@keyframes markas-shooting-star{0%{transform:rotate(215deg) translateX(0);opacity:0}2%{opacity:1}14%,to{transform:rotate(215deg) translateX(-360px);opacity:0}}";

/** Park-Miller: integer math only, so every framework draws the same sky. */
const MODULUS = 2147483647;
const MULTIPLIER = 48271;
const MAX_STARS = 300;
const STREAKS = 3;
const JITTER_MS = 1000;

export type ShootingStarsVariant = keyof typeof variants;
export type ShootingStarsFrequency = keyof typeof frequencies;
export type ShootingStarsTrailColor = keyof typeof trailColors;

function makeSky(
  variant: ShootingStarsVariant,
  count: number,
  seed: number,
  frequency: ShootingStarsFrequency,
) {
  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_STARS));
  const sky = variants[variant].sky;
  const stars = Array.from({ length: total }, () => {
    const size = next() % 6 === 0 ? 2 : 1;
    const left = (next() % 10000) / 100;
    const top = (next() % (sky * 100)) / 100;
    const opacity = ((next() % 6) + 3) / 10;
    const delay = (next() % 30) * 100;
    const duration = (next() % 3) + 2;
    return `left: ${left}%; top: ${top}%; width: ${size}px; height: ${size}px; opacity: ${opacity}; animation-delay: ${delay}ms; animation-duration: ${duration}s`;
  });
  const cycle = frequencies[frequency] ?? frequencies.normal;
  const streaks = Array.from({ length: STREAKS }, (_, i) => {
    const left = 20 + (next() % 60);
    const top = next() % 45;
    const width = 80 + (next() % 60);
    const delay = -(
      ((STREAKS - i) % STREAKS) * (cycle / STREAKS) +
      (next() % JITTER_MS)
    );
    return `left: ${left}%; top: ${top}%; width: ${width}px; animation-duration: ${cycle}ms; animation-delay: ${delay}ms`;
  });
  return { stars, streaks };
}

/**
 * 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-shooting-stars]",
  changeDetection: ChangeDetectionStrategy.OnPush,
  encapsulation: ViewEncapsulation.None,
  styles: [keyframes],
  host: { "[class]": "base" },
  template: `
    <div aria-hidden="true" [class]="layerClasses()">
      @if (config().glow) {
        <div [class]="config().glow"></div>
      }
      @for (style of sky().stars; track $index) {
        <span [class]="star" [style]="style"></span>
      }
      @for (style of sky().streaks; track $index) {
        <span [class]="streak" [style]="style"></span>
      }
    </div>
    <div [class]="content"><ng-content /></div>
  `,
})
export class ShootingStars {
  readonly variant = input<ShootingStarsVariant>("night");
  readonly frequency = input<ShootingStarsFrequency>("normal");
  readonly trailColor = input<ShootingStarsTrailColor>();
  readonly stars = input(70, { transform: numberAttribute });
  readonly seed = input(11, { transform: numberAttribute });

  protected readonly base = base;
  protected readonly star = star;
  protected readonly streak = streak;
  protected readonly content = content;
  private readonly key = computed<ShootingStarsVariant>(() =>
    this.variant() in variants ? this.variant() : "night",
  );
  protected readonly config = computed(() => variants[this.key()]);
  protected readonly layerClasses = computed(
    () =>
      `${layer} ${trailColors[this.trailColor() ?? this.config().trail] ?? trailColors.primary}`,
  );
  protected readonly sky = computed(() =>
    makeSky(this.key(), this.stars(), this.seed(), this.frequency()),
  );
}
```

```ts
import { Component } from "@angular/core";
import { Button } from "./markas/button.component";
import { ShootingStars } from "./markas/shooting-stars.component";

@Component({
  selector: "app-waitlist",
  imports: [Button, ShootingStars],
  template: `
    <div
      markas-shooting-stars
      variant="night"
      frequency="normal"
      trailColor="primary"
      class="dark rounded-xl bg-canvas px-6 py-14"
    >
      <h2 class="text-2xl font-semibold text-ink">Make a wish, then ship it</h2>
      <button markas-button>Join the waitlist</button>
    </div>
  `,
})
export class Waitlist {}
```

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

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `variant` | `night \| dawn` | night | night: bintang di seluruh area. dawn: bintang di langit atas dengan cahaya hangat naik dari bawah. |
| `frequency` | `low \| normal \| high` | normal | Seberapa sering bintang jatuh muncul: kira-kira tiap 5, 3, atau 1,5 detik. |
| `trailColor` | `muted \| ink \| primary \| success \| warning \| danger` | primary (night), warning (dawn) | Warna token ekor bintang jatuh. Kepalanya selalu memakai ink. |
| `stars` | `number` | 70 | Jumlah bintang latar yang berkelip, maksimal 300. |
| `seed` | `number` | 11 | Bilangan bulat yang menentukan posisi bintang dan lintasan. Seed sama selalu menghasilkan langit yang sama. |
| `children / slot` | `slot / ReactNode` | - | Konten yang tampil di atas langit. |

## Aksesibilitas

- Lapisan langit memakai aria-hidden dan mengabaikan pointer.
- Dengan reduced motion, bintang berhenti berkelip dan bintang jatuh diam sebagai garis pendek.

## Catatan

- Tiga bintang jatuh berbagi satu putaran CSS, jadi satu melintas setiap sepertiga putaran. Di sisa putaran mereka tidak terlihat.
- Posisi bintang dan lintasan dihitung dari `seed` dengan bilangan bulat, jadi semua framework merender langit yang sama.
- Komponen ini terpisah dari Stars Background dengan keyframe sendiri, jadi keduanya bisa ada di halaman yang sama.
- Dengan reduced motion bintang berhenti berkelip dan lintasan diam.
- Komponen ini tidak punya teks bawaan, jadi tidak ada prop label yang perlu diterjemahkan.
