# Letter Swap

Teks yang hurufnya bergeser keluar lalu masuk lagi berurutan saat link atau tombolnya di-hover atau difokus. Urutan maju, bolak-balik, atau acak.

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

## Kapan dipakai

Link navbar, label tombol, dan link footer pendek yang butuh hover jenaka tanpa mengubah tata letak.

- Letakkan komponen di dalam link atau tombol; komponen mendengarkan hover dan fokus elemen itu
- Pakai teks pendek, satu sampai tiga kata
- Pakai pingpong untuk tombol yang lama di-hover, forward atau random untuk link
- Blade butuh Alpine.js

## Kode

### Blade

Simpan di `resources/views/components/markas/letter-swap.blade.php`. Dependensi: alpinejs.

```blade
@props([
    'text' => '',
    'mode' => 'forward',
    'direction' => 'up',
    'stagger' => 30,
    'duration' => 400,
])

@php
    $root = 'relative inline-flex overflow-hidden';
    $letter = 'relative inline-block whitespace-pre';
    $copies = [
        'up' => 'absolute inset-x-0 top-full',
        'down' => 'absolute inset-x-0 bottom-full',
    ];

    $chars = mb_str_split((string) $text);
@endphp

<span
    x-data="{
        cleanup: () => {},
        init() {
            if (window.matchMedia?.('(prefers-reduced-motion: reduce)').matches) return;
            const mode = @js($mode);
            const stagger = @js((int) $stagger);
            const duration = @js((int) $duration);
            const easing = 'cubic-bezier(0.22, 1, 0.36, 1)';
            {{-- Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. --}}
            const target = this.$el.closest('a, button, label, [tabindex]') ?? this.$el;
            const letters = [...this.$el.querySelectorAll('[data-letter]')];
            {{-- Peringkat stagger tiap huruf. Mode random memakai urutan acak tetap (hash). --}}
            const order = [...Array(letters.length).keys()];
            const hash = (i) => Math.imul(i + 1, 2654435761) >>> 0;
            if (mode === 'random') order.sort((a, b) => hash(a) - hash(b));
            const rank = [];
            order.forEach((index, position) => (rank[index] = position));
            const shift = @js($direction === 'up' ? 'translateY(-100%)' : 'translateY(100%)');
            let busyUntil = 0;
            {{-- Pingpong: transisi CSS bolak-balik. Forward/random: sekali jalan lalu kembali tanpa terlihat. --}}
            const move = (enter) => {
                const now = performance.now();
                if (mode !== 'pingpong') {
                    if (! enter || now < busyUntil) return;
                    busyUntil = now + duration + stagger * letters.length;
                }
                letters.forEach((el, i) => {
                    const delay = rank[i] * stagger;
                    if (mode !== 'pingpong') {
                        el.animate?.([{ transform: 'none' }, { transform: shift }], { duration, delay, easing });
                        return;
                    }
                    el.style.transition = `transform ${duration}ms ${easing} ${delay}ms`;
                    el.style.transform = enter ? shift : '';
                });
            };
            const enter = () => move(true);
            const leave = () => move(false);
            target.addEventListener('pointerenter', enter);
            target.addEventListener('focusin', enter);
            target.addEventListener('pointerleave', leave);
            target.addEventListener('focusout', leave);
            this.cleanup = () => {
                target.removeEventListener('pointerenter', enter);
                target.removeEventListener('focusin', enter);
                target.removeEventListener('pointerleave', leave);
                target.removeEventListener('focusout', leave);
            };
        },
        destroy() {
            this.cleanup();
        },
    }"
    {{ $attributes->class([$root]) }}
><span class="sr-only">{{ $text }}</span>@foreach ($chars as $char)<span aria-hidden="true" data-letter class="{{ $letter }}">{{ $char }}<span class="{{ $copies[$direction] }}">{{ $char }}</span></span>@endforeach</span>
```

```blade
<a href="/pricing" class="text-sm font-medium">
    <x-markas.letter-swap text="Pricing" />
</a>
<button type="button" class="h-10 rounded-lg bg-primary px-4 text-on-primary">
    <x-markas.letter-swap text="Coba gratis" mode="pingpong" direction="down" />
</button>
<a href="/careers"><x-markas.letter-swap text="Karier" mode="random" /></a>
```

### React

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

```tsx
"use client";

import { useEffect, useRef, type ComponentProps } from "react";

const root = "relative inline-flex overflow-hidden";
const letter = "relative inline-block whitespace-pre";
const copies = {
  up: "absolute inset-x-0 top-full",
  down: "absolute inset-x-0 bottom-full",
};

const EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
/** Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. */
const TRIGGER = "a, button, label, [tabindex]";

const cx = (...c: (string | false | null | undefined)[]) =>
  c.filter(Boolean).join(" ");

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Peringkat stagger tiap huruf. Mode random memakai urutan acak tetap (hash), sama di setiap render. */
function ranks(count: number, random: boolean) {
  const order = [...Array(count).keys()];
  const hash = (i: number) => Math.imul(i + 1, 2654435761) >>> 0;
  if (random) order.sort((a, b) => hash(a) - hash(b));
  const rank: number[] = [];
  order.forEach((index, position) => (rank[index] = position));
  return rank;
}

export type LetterSwapProps = Omit<ComponentProps<"span">, "children"> & {
  text: string;
  mode?: "forward" | "pingpong" | "random";
  direction?: keyof typeof copies;
  stagger?: number;
  duration?: number;
};

export function LetterSwap({
  text,
  mode = "forward",
  direction = "up",
  stagger = 30,
  duration = 400,
  className,
  ...props
}: LetterSwapProps) {
  const rootRef = useRef<HTMLSpanElement>(null);

  useEffect(() => {
    const element = rootRef.current;
    if (!element || reducedMotion()) return;
    const target = element.closest<HTMLElement>(TRIGGER) ?? element;
    const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
    const rank = ranks(letters.length, mode === "random");
    const shift = `translateY(${direction === "up" ? "-100%" : "100%"})`;
    let busyUntil = 0;

    // Pingpong: transisi CSS bolak-balik. Forward/random: sekali jalan lalu kembali tanpa terlihat.
    const move = (enter: boolean) => {
      const now = performance.now();
      if (mode !== "pingpong") {
        if (!enter || now < busyUntil) return;
        busyUntil = now + duration + stagger * letters.length;
      }
      letters.forEach((el, i) => {
        const delay = rank[i]! * stagger;
        if (mode !== "pingpong") {
          el.animate?.([{ transform: "none" }, { transform: shift }], {
            duration,
            delay,
            easing: EASING,
          });
          return;
        }
        el.style.transition = `transform ${duration}ms ${EASING} ${delay}ms`;
        el.style.transform = enter ? shift : "";
      });
    };
    const enter = () => move(true);
    const leave = () => move(false);
    target.addEventListener("pointerenter", enter);
    target.addEventListener("focusin", enter);
    target.addEventListener("pointerleave", leave);
    target.addEventListener("focusout", leave);
    return () => {
      target.removeEventListener("pointerenter", enter);
      target.removeEventListener("focusin", enter);
      target.removeEventListener("pointerleave", leave);
      target.removeEventListener("focusout", leave);
      letters.forEach((el) => {
        el.style.transition = "";
        el.style.transform = "";
      });
    };
  }, [text, mode, direction, stagger, duration]);

  return (
    <span ref={rootRef} {...props} className={cx(root, className)}>
      <span className="sr-only">{text}</span>
      {Array.from(text).map((char, index) => (
        <span key={index} aria-hidden="true" data-letter="" className={letter}>
          {char}
          <span className={copies[direction]}>{char}</span>
        </span>
      ))}
    </span>
  );
}
```

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

<a href="/pricing" className="text-sm font-medium">
  <LetterSwap text="Pricing" />
</a>
<button type="button" className="h-10 rounded-lg bg-primary px-4 text-on-primary">
  <LetterSwap text="Coba gratis" mode="pingpong" direction="down" />
</button>
<a href="/careers"><LetterSwap text="Karier" mode="random" /></a>
```

### Vue

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

```vue
<script setup lang="ts">
import {
  computed,
  onBeforeUnmount,
  onMounted,
  useTemplateRef,
  watch,
} from "vue";

const props = withDefaults(
  defineProps<{
    text: string;
    mode?: "forward" | "pingpong" | "random";
    direction?: "up" | "down";
    stagger?: number;
    duration?: number;
  }>(),
  { mode: "forward", direction: "up", stagger: 30, duration: 400 },
);

const root = "relative inline-flex overflow-hidden";
const letter = "relative inline-block whitespace-pre";
const copies = {
  up: "absolute inset-x-0 top-full",
  down: "absolute inset-x-0 bottom-full",
};

const EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
/** Hover dan fokus didengar di elemen interaktif terdekat (link, tombol), atau di teks itu sendiri. */
const TRIGGER = "a, button, label, [tabindex]";

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Peringkat stagger tiap huruf. Mode random memakai urutan acak tetap (hash), sama di setiap render. */
function ranks(count: number, random: boolean) {
  const order = [...Array(count).keys()];
  const hash = (i: number) => Math.imul(i + 1, 2654435761) >>> 0;
  if (random) order.sort((a, b) => hash(a) - hash(b));
  const rank: number[] = [];
  order.forEach((index, position) => (rank[index] = position));
  return rank;
}

const chars = computed(() => Array.from(props.text));
const rootEl = useTemplateRef<HTMLSpanElement>("rootRef");
let cleanup = () => {};

function start() {
  cleanup();
  const element = rootEl.value;
  if (!element || reducedMotion()) return;
  const { mode, direction, stagger, duration } = props;
  const target = element.closest<HTMLElement>(TRIGGER) ?? element;
  const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
  const rank = ranks(letters.length, mode === "random");
  const shift = `translateY(${direction === "up" ? "-100%" : "100%"})`;
  let busyUntil = 0;

  // Pingpong: transisi CSS bolak-balik. Forward/random: sekali jalan lalu kembali tanpa terlihat.
  const move = (enter: boolean) => {
    const now = performance.now();
    if (mode !== "pingpong") {
      if (!enter || now < busyUntil) return;
      busyUntil = now + duration + stagger * letters.length;
    }
    letters.forEach((el, i) => {
      const delay = rank[i]! * stagger;
      if (mode !== "pingpong") {
        el.animate?.([{ transform: "none" }, { transform: shift }], {
          duration,
          delay,
          easing: EASING,
        });
        return;
      }
      el.style.transition = `transform ${duration}ms ${EASING} ${delay}ms`;
      el.style.transform = enter ? shift : "";
    });
  };
  const enter = () => move(true);
  const leave = () => move(false);
  target.addEventListener("pointerenter", enter);
  target.addEventListener("focusin", enter);
  target.addEventListener("pointerleave", leave);
  target.addEventListener("focusout", leave);
  cleanup = () => {
    target.removeEventListener("pointerenter", enter);
    target.removeEventListener("focusin", enter);
    target.removeEventListener("pointerleave", leave);
    target.removeEventListener("focusout", leave);
    letters.forEach((el) => {
      el.style.transition = "";
      el.style.transform = "";
    });
  };
}

onMounted(start);
watch(
  () => [
    props.text,
    props.mode,
    props.direction,
    props.stagger,
    props.duration,
  ],
  start,
  { flush: "post" },
);
onBeforeUnmount(() => cleanup());
</script>

<template>
  <span ref="rootRef" :class="root"
    ><span class="sr-only">{{ props.text }}</span
    ><span
      v-for="(char, index) in chars"
      :key="index"
      aria-hidden="true"
      data-letter
      :class="letter"
      >{{ char }}<span :class="copies[props.direction]">{{ char }}</span></span
    ></span
  >
</template>
```

```vue
<template>
  <a href="/pricing" class="text-sm font-medium">
    <LetterSwap text="Pricing" />
  </a>
  <button type="button" class="h-10 rounded-lg bg-primary px-4 text-on-primary">
    <LetterSwap text="Coba gratis" mode="pingpong" direction="down" />
  </button>
  <a href="/careers"><LetterSwap text="Karier" mode="random" /></a>
</template>
```

### Svelte

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

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

  const root = "relative inline-flex overflow-hidden";
  const letter = "relative inline-block whitespace-pre";
  const copies = {
    up: "absolute inset-x-0 top-full",
    down: "absolute inset-x-0 bottom-full",
  };

  const EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
  /** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
  const TRIGGER = "a, button, label, [tabindex]";

  const reducedMotion = () =>
    typeof matchMedia === "function" &&
    matchMedia("(prefers-reduced-motion: reduce)").matches;

  /** Stagger rank of each letter. Random mode uses a fixed shuffled order (hash), the same on every render. */
  function ranks(count: number, random: boolean) {
    const order = [...Array(count).keys()];
    const hash = (i: number) => Math.imul(i + 1, 2654435761) >>> 0;
    if (random) order.sort((a, b) => hash(a) - hash(b));
    const rank: number[] = [];
    order.forEach((index, position) => (rank[index] = position));
    return rank;
  }

  type Props = Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
    text: string;
    mode?: "forward" | "pingpong" | "random";
    direction?: keyof typeof copies;
    stagger?: number;
    duration?: number;
  };

  let {
    text,
    mode = "forward",
    direction = "up",
    stagger = 30,
    duration = 400,
    class: className,
    ...rest
  }: Props = $props();

  let element = $state<HTMLSpanElement>();
  const chars = $derived(Array.from(text));

  $effect(() => {
    // Read every prop up front so the effect reruns when one changes.
    const options = { mode, direction, stagger, duration, count: chars.length };
    if (!element || reducedMotion()) return;
    const target = element.closest<HTMLElement>(TRIGGER) ?? element;
    const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
    const rank = ranks(letters.length, options.mode === "random");
    const shift = `translateY(${options.direction === "up" ? "-100%" : "100%"})`;
    let busyUntil = 0;

    // Pingpong: a CSS transition back and forth. Forward and random: one pass, then an invisible reset.
    const move = (enter: boolean) => {
      const now = performance.now();
      if (options.mode !== "pingpong") {
        if (!enter || now < busyUntil) return;
        busyUntil = now + options.duration + options.stagger * letters.length;
      }
      letters.forEach((el, i) => {
        const delay = rank[i]! * options.stagger;
        if (options.mode !== "pingpong") {
          el.animate?.([{ transform: "none" }, { transform: shift }], {
            duration: options.duration,
            delay,
            easing: EASING,
          });
          return;
        }
        el.style.transition = `transform ${options.duration}ms ${EASING} ${delay}ms`;
        el.style.transform = enter ? shift : "";
      });
    };
    const enter = () => move(true);
    const leave = () => move(false);
    target.addEventListener("pointerenter", enter);
    target.addEventListener("focusin", enter);
    target.addEventListener("pointerleave", leave);
    target.addEventListener("focusout", leave);
    return () => {
      target.removeEventListener("pointerenter", enter);
      target.removeEventListener("focusin", enter);
      target.removeEventListener("pointerleave", leave);
      target.removeEventListener("focusout", leave);
      letters.forEach((el) => {
        el.style.transition = "";
        el.style.transform = "";
      });
    };
  });
</script>

<span bind:this={element} {...rest} class={[root, className]}
  ><span class="sr-only">{text}</span>{#each chars as char, index (index)}<span
      aria-hidden="true"
      data-letter=""
      class={letter}>{char}<span class={copies[direction]}>{char}</span></span
    >{/each}</span
>
```

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

<a href="/pricing" class="text-sm font-medium">
  <LetterSwap text="Pricing" />
</a>
<button type="button" class="h-10 rounded-lg bg-primary px-4 text-on-primary">
  <LetterSwap text="Start free trial" mode="pingpong" direction="down" />
</button>
```

### Astro

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

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

const root = "relative inline-flex overflow-hidden";
const letter = "relative inline-block whitespace-pre";
const copies = {
  up: "absolute inset-x-0 top-full",
  down: "absolute inset-x-0 bottom-full",
};

type Props = Omit<HTMLAttributes<"span">, "children"> & {
  text: string;
  mode?: "forward" | "pingpong" | "random";
  direction?: keyof typeof copies;
  stagger?: number;
  duration?: number;
};

const {
  text,
  mode = "forward",
  direction = "up",
  stagger = 30,
  duration = 400,
  class: className,
  ...rest
} = Astro.props;
---

<markas-letter-swap class="contents" data-mode={mode} data-direction={direction} data-stagger={stagger} data-duration={duration}><span {...rest} class:list={[root, className]}><span class="sr-only">{text}</span>{Array.from(text).map((char) => <span aria-hidden="true" data-letter="" class={letter}>{char}<span class={copies[direction]}>{char}</span></span>)}</span></markas-letter-swap>

<script>
  const EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
  /** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
  const TRIGGER = "a, button, label, [tabindex]";
  const EVENTS = ["pointerenter", "focusin", "pointerleave", "focusout"];

  /** Stagger rank of each letter. Random mode uses a fixed shuffled order (hash), the same on every render. */
  function ranks(count: number, random: boolean) {
    const order = [...Array(count).keys()];
    const hash = (i: number) => Math.imul(i + 1, 2654435761) >>> 0;
    if (random) order.sort((a, b) => hash(a) - hash(b));
    const rank: number[] = [];
    order.forEach((index, position) => (rank[index] = position));
    return rank;
  }

  // One element per instance: setup runs for markup added later and after view transitions.
  class MarkasLetterSwap extends HTMLElement {
    private cleanup = () => {};

    connectedCallback() {
      const element = this.firstElementChild as HTMLElement | null;
      if (!element || matchMedia("(prefers-reduced-motion: reduce)").matches)
        return;
      const { mode = "forward", direction = "up" } = this.dataset;
      const stagger = Number(this.dataset.stagger);
      const duration = Number(this.dataset.duration);
      const target = element.closest<HTMLElement>(TRIGGER) ?? element;
      const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
      const rank = ranks(letters.length, mode === "random");
      const shift = `translateY(${direction === "up" ? "-100%" : "100%"})`;
      let busyUntil = 0;

      // Pingpong: a CSS transition back and forth. Forward and random: one pass, then an invisible reset.
      const move = (event: Event) => {
        const enter = EVENTS.indexOf(event.type) < 2;
        const now = performance.now();
        if (mode !== "pingpong") {
          if (!enter || now < busyUntil) return;
          busyUntil = now + duration + stagger * letters.length;
        }
        letters.forEach((el, i) => {
          const delay = rank[i]! * stagger;
          if (mode !== "pingpong") {
            el.animate?.([{ transform: "none" }, { transform: shift }], {
              duration,
              delay,
              easing: EASING,
            });
            return;
          }
          el.style.transition = `transform ${duration}ms ${EASING} ${delay}ms`;
          el.style.transform = enter ? shift : "";
        });
      };
      EVENTS.forEach((name) => target.addEventListener(name, move));
      this.cleanup = () =>
        EVENTS.forEach((name) => target.removeEventListener(name, move));
    }

    disconnectedCallback() {
      this.cleanup();
    }
  }

  if (!customElements.get("markas-letter-swap"))
    customElements.define("markas-letter-swap", MarkasLetterSwap);
</script>
```

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

<a href="/pricing" class="text-sm font-medium">
  <LetterSwap text="Pricing" />
</a>
<a href="/careers"><LetterSwap text="Careers" mode="random" /></a>
```

### Angular

Simpan di `src/app/markas/letter-swap.component.ts`. Tanpa dependensi tambahan.

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

const root = "relative inline-flex overflow-hidden";
const letter = "relative inline-block whitespace-pre";
const copies = {
  up: "absolute inset-x-0 top-full",
  down: "absolute inset-x-0 bottom-full",
};

const EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
/** Hover and focus are heard on the closest interactive element (link, button), or on the text itself. */
const TRIGGER = "a, button, label, [tabindex]";
const EVENTS = ["pointerenter", "focusin", "pointerleave", "focusout"];

const reducedMotion = () =>
  typeof matchMedia === "function" &&
  matchMedia("(prefers-reduced-motion: reduce)").matches;

/** Stagger rank of each letter. Random mode uses a fixed shuffled order (hash), the same on every render. */
function ranks(count: number, random: boolean) {
  const order = [...Array(count).keys()];
  const hash = (i: number) => Math.imul(i + 1, 2654435761) >>> 0;
  if (random) order.sort((a, b) => hash(a) - hash(b));
  const rank: number[] = [];
  order.forEach((index, position) => (rank[index] = position));
  return rank;
}

export type LetterSwapMode = "forward" | "pingpong" | "random";
export type LetterSwapDirection = keyof typeof copies;

type SwapOptions = {
  mode: LetterSwapMode;
  direction: LetterSwapDirection;
  stagger: number;
  duration: number;
};

/** Listens for hover and focus and swaps every letter. Returns a cleanup function. */
function startSwap(element: HTMLElement, options: SwapOptions) {
  const { mode, stagger, duration } = options;
  const target = element.closest<HTMLElement>(TRIGGER) ?? element;
  const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
  const rank = ranks(letters.length, mode === "random");
  const shift = `translateY(${options.direction === "up" ? "-100%" : "100%"})`;
  let busyUntil = 0;

  // Pingpong: a CSS transition back and forth. Forward and random: one pass, then an invisible reset.
  const move = (event: Event) => {
    const enter = EVENTS.indexOf(event.type) < 2;
    const now = performance.now();
    if (mode !== "pingpong") {
      if (!enter || now < busyUntil) return;
      busyUntil = now + duration + stagger * letters.length;
    }
    letters.forEach((el, i) => {
      const delay = rank[i]! * stagger;
      if (mode !== "pingpong") {
        el.animate?.([{ transform: "none" }, { transform: shift }], {
          duration,
          delay,
          easing: EASING,
        });
        return;
      }
      el.style.transition = `transform ${duration}ms ${EASING} ${delay}ms`;
      el.style.transform = enter ? shift : "";
    });
  };
  EVENTS.forEach((name) => target.addEventListener(name, move));
  return () => {
    EVENTS.forEach((name) => target.removeEventListener(name, move));
    letters.forEach((el) => {
      el.style.transition = "";
      el.style.transform = "";
    });
  };
}

/** Attribute selector on a span: class and other attributes stay on the root. */
@Component({
  selector: "span[markas-letter-swap]",
  changeDetection: ChangeDetectionStrategy.OnPush,
  host: { "[class]": "root" },
  template: `<span class="sr-only">{{ text() }}</span>
    @for (char of chars(); track $index) {
      <span aria-hidden="true" data-letter="" [class]="letter"
        >{{ char }}<span [class]="copyClass()">{{ char }}</span></span
      >
    }`,
})
export class LetterSwap {
  readonly text = input.required<string>();
  readonly mode = input<LetterSwapMode>("forward");
  readonly direction = input<LetterSwapDirection>("up");
  readonly stagger = input(30, { transform: numberAttribute });
  readonly duration = input(400, { transform: numberAttribute });

  protected readonly root = root;
  protected readonly letter = letter;
  protected readonly chars = computed(() => Array.from(this.text()));
  protected readonly copyClass = computed(() => copies[this.direction()]);
  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);

  constructor() {
    afterRenderEffect((onCleanup) => {
      const options = {
        mode: this.mode(),
        direction: this.direction(),
        stagger: this.stagger(),
        duration: this.duration(),
      };
      this.chars();
      if (reducedMotion()) return;
      onCleanup(startSwap(this.host.nativeElement, options));
    });
  }
}
```

```ts
import { Component } from "@angular/core";
import { LetterSwap } from "./markas/letter-swap.component";

@Component({
  selector: "app-nav-link",
  imports: [LetterSwap],
  template: `
    <a href="/pricing" class="text-sm font-medium">
      <span markas-letter-swap text="Pricing"></span>
    </a>
    <button
      type="button"
      class="h-10 rounded-lg bg-primary px-4 text-on-primary"
    >
      <span markas-letter-swap text="Start free trial" mode="pingpong"></span>
    </button>
  `,
})
export class NavLink {}
```

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `text` | `string` | - | Teks yang dianimasikan. Screen reader membacanya sekali secara utuh. |
| `mode` | `"forward" \| "pingpong" \| "random"` | "forward" | forward bertukar sekali per hover sesuai urutan baca, pingpong bertukar saat hover dan kembali saat kursor pergi, random bertukar sekali dengan urutan acak yang tetap. |
| `direction` | `"up" \| "down"` | "up" | Huruf keluar ke atas dan salinannya naik dari bawah, atau sebaliknya. |
| `stagger` | `number` | 30 | Milidetik antara satu huruf dan huruf berikutnya. |
| `duration` | `number` | 400 | Milidetik yang dibutuhkan setiap huruf untuk bertukar. |

## Aksesibilitas

- Teks utuh ada di salinan tersembunyi sehingga link atau tombol mendapat satu nama aksesibel yang bersih; huruf yang bergerak memakai aria-hidden.
- Pertukaran juga berjalan saat fokus keyboard pada link, tombol, label, atau elemen ber-tabindex terdekat.
- Dengan reduced motion, huruf tidak bergerak.

## Catatan

- Letakkan komponen di dalam link atau tombol. Komponen mendengarkan hover dan fokus pada `a`, `button`, `label`, atau elemen ber-`tabindex` terdekat, sehingga pengguna keyboard melihat pertukaran yang sama.
- `forward` dan `random` berjalan sekali per hover dan mengabaikan hover baru sampai selesai. `pingpong` bertukar saat hover dan kembali saat kursor pergi atau fokus lepas.
- Urutan acak berasal dari hash tetap, sehingga sama di setiap render dan di setiap framework.
- Screen reader membaca teks sekali dari salinan tersembunyi. Dengan reduced motion, huruf diam. Versi Blade butuh Alpine.js.
