# Variable Weight Text

Teks yang hurufnya makin tebal saat kursor makin dekat, memakai sumbu wght font variabel. Ada gelombang opsional yang bernapas saat diam.

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

## Kapan dipakai

Kata display besar di hero atau wordmark footer yang bereaksi terhadap kursor.

- Butuh font variabel dengan sumbu wght; dengan font statis, berat melompat di antara berat yang tersedia
- Pakai ukuran besar, text-5xl ke atas, agar perubahannya terlihat
- Pakai teks pendek, satu sampai tiga kata
- Blade butuh Alpine.js

## Kode

### Blade

Simpan di `resources/views/components/markas/variable-weight-text.blade.php`. Dependensi: alpinejs.

```blade
@props([
    'text' => '',
    'radius' => 120,
    'min' => 300,
    'max' => 800,
    'wave' => false,
])

@php
    $root = 'inline';
    $letter = 'transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none';

    $chars = mb_str_split((string) $text);
    // Berat awal lewat sumbu wght font variabel, dengan font-weight sebagai cadangan.
    $rest = "font-variation-settings: 'wght' ".(int) $min.'; font-weight: '.(int) $min;
@endphp

<span
    x-data="{
        cleanup: () => {},
        init() {
            if (window.matchMedia?.('(prefers-reduced-motion: reduce)').matches) return;
            const radius = @js((float) $radius);
            const min = @js((int) $min);
            const span = @js((int) $max) - min;
            const wave = @js((bool) $wave);
            const letters = [...this.$el.querySelectorAll('[data-letter]')];
            const set = (values) => letters.forEach((el, i) => {
                el.style.fontVariationSettings = `'wght' ${values[i]}`;
                el.style.fontWeight = String(values[i]);
            });
            let pointer;
            let visible = false;
            let frame = 0;
            {{-- Huruf terdekat dari kursor paling tebal; di luar radius kembali ke min. Tanpa kursor, wave bernapas (2400 ms per napas, fase 0.45 rad antarhuruf). --}}
            const draw = (now) => {
                frame = 0;
                const near = pointer ? letters.map((el) => {
                    const rect = el.getBoundingClientRect();
                    const distance = Math.hypot(pointer.x - (rect.left + rect.width / 2), pointer.y - (rect.top + rect.height / 2));
                    return Math.min(distance / radius, 1);
                }) : [];
                if (near.some((t) => t < 1)) return set(near.map((t) => Math.round(min + span * (0.5 + 0.5 * Math.cos(Math.PI * t)))));
                if (! wave) return set(letters.map(() => min));
                set(letters.map((_, i) => Math.round(min + span * (0.5 - 0.5 * Math.cos((now / 2400) * 2 * Math.PI - i * 0.45)))));
                if (visible) frame = requestAnimationFrame(draw);
            };
            const schedule = () => {
                if (! frame && visible) frame = requestAnimationFrame(draw);
            };
            const move = (event) => {
                pointer = { x: event.clientX, y: event.clientY };
                schedule();
            };
            const out = () => {
                pointer = undefined;
                schedule();
            };
            const observer = typeof IntersectionObserver === 'undefined' ? undefined : new IntersectionObserver((entries) => {
                visible = entries.some((entry) => entry.isIntersecting);
                cancelAnimationFrame(frame);
                frame = 0;
                schedule();
            });
            visible = ! observer;
            observer?.observe(this.$el);
            schedule();
            addEventListener('pointermove', move);
            document.documentElement.addEventListener('pointerleave', out);
            this.cleanup = () => {
                observer?.disconnect();
                cancelAnimationFrame(frame);
                removeEventListener('pointermove', move);
                document.documentElement.removeEventListener('pointerleave', out);
            };
        },
        destroy() {
            this.cleanup();
        },
    }"
    {{ $attributes->class([$root]) }}
><span class="sr-only">{{ $text }}</span>@foreach ($chars as $char)<span aria-hidden="true" data-letter class="{{ $letter }}" style="{{ $rest }}">{{ $char }}</span>@endforeach</span>
```

```blade
<p class="text-6xl">
    <x-markas.variable-weight-text text="Kedekatan" :radius="100" :min="200" :max="900" />
</p>
<x-markas.variable-weight-text text="markasui" wave class="text-7xl" />
```

### React

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

```tsx
"use client";

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

const root = "inline";
const letter =
  "transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none";

/** Satu napas gelombang (ms) dan selisih fase antarhuruf (radian). */
const WAVE_PERIOD = 2400;
const WAVE_PHASE = 0.45;

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

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

/** Atur berat huruf lewat sumbu wght font variabel, dengan font-weight sebagai cadangan. */
const weight = (value: number) => ({
  fontVariationSettings: `'wght' ${value}`,
  fontWeight: value,
});

export type VariableWeightTextProps = Omit<
  ComponentProps<"span">,
  "children"
> & {
  text: string;
  radius?: number;
  min?: number;
  max?: number;
  wave?: boolean;
};

export function VariableWeightText({
  text,
  radius = 120,
  min = 300,
  max = 800,
  wave = false,
  className,
  ...props
}: VariableWeightTextProps) {
  const rootRef = useRef<HTMLSpanElement>(null);

  useEffect(() => {
    const element = rootRef.current;
    if (!element || reducedMotion()) return;
    const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
    const set = (values: number[]) =>
      letters.forEach((el, i) => Object.assign(el.style, weight(values[i]!)));
    let pointer: { x: number; y: number } | undefined;
    let visible = false;
    let frame = 0;

    // Huruf terdekat dari kursor paling tebal; di luar radius kembali ke min. Tanpa kursor, wave bernapas.
    const draw = (now: number) => {
      frame = 0;
      const span = max - min;
      const near = pointer
        ? letters.map((el) => {
            const rect = el.getBoundingClientRect();
            const distance = Math.hypot(
              pointer!.x - (rect.left + rect.width / 2),
              pointer!.y - (rect.top + rect.height / 2),
            );
            return Math.min(distance / radius, 1);
          })
        : [];
      if (near.some((t) => t < 1))
        return set(
          near.map((t) =>
            Math.round(min + span * (0.5 + 0.5 * Math.cos(Math.PI * t))),
          ),
        );
      if (!wave) return set(letters.map(() => min));
      set(
        letters.map((_, i) =>
          Math.round(
            min +
              span *
                (0.5 -
                  0.5 *
                    Math.cos(
                      (now / WAVE_PERIOD) * 2 * Math.PI - i * WAVE_PHASE,
                    )),
          ),
        ),
      );
      if (visible) frame = requestAnimationFrame(draw);
    };
    const schedule = () => {
      if (!frame && visible) frame = requestAnimationFrame(draw);
    };
    const move = (event: PointerEvent) => {
      pointer = { x: event.clientX, y: event.clientY };
      schedule();
    };
    const out = () => {
      pointer = undefined;
      schedule();
    };

    const observer =
      typeof IntersectionObserver === "undefined"
        ? undefined
        : new IntersectionObserver((entries) => {
            visible = entries.some((entry) => entry.isIntersecting);
            cancelAnimationFrame(frame);
            frame = 0;
            schedule();
          });
    visible = !observer;
    observer?.observe(element);
    schedule();
    addEventListener("pointermove", move);
    document.documentElement.addEventListener("pointerleave", out);
    return () => {
      observer?.disconnect();
      cancelAnimationFrame(frame);
      removeEventListener("pointermove", move);
      document.documentElement.removeEventListener("pointerleave", out);
      set(letters.map(() => min));
    };
  }, [text, radius, min, max, wave]);

  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}
          style={weight(min)}
        >
          {char}
        </span>
      ))}
    </span>
  );
}
```

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

<p className="text-6xl">
  <VariableWeightText text="Kedekatan" radius={100} min={200} max={900} />
</p>
<VariableWeightText text="markasui" wave className="text-7xl" />
```

### Vue

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

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

const props = withDefaults(
  defineProps<{
    text: string;
    radius?: number;
    min?: number;
    max?: number;
    wave?: boolean;
  }>(),
  { radius: 120, min: 300, max: 800, wave: false },
);

const root = "inline";
const letter =
  "transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none";

/** Satu napas gelombang (ms) dan selisih fase antarhuruf (radian). */
const WAVE_PERIOD = 2400;
const WAVE_PHASE = 0.45;

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

/** Atur berat huruf lewat sumbu wght font variabel, dengan font-weight sebagai cadangan. */
const weight = (value: number) => ({
  fontVariationSettings: `'wght' ${value}`,
  fontWeight: value,
});

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 { radius, min, max, wave } = props;
  const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
  const set = (values: number[]) =>
    letters.forEach((el, i) => {
      el.style.fontVariationSettings = `'wght' ${values[i]}`;
      el.style.fontWeight = String(values[i]);
    });
  let pointer: { x: number; y: number } | undefined;
  let visible = false;
  let frame = 0;

  // Huruf terdekat dari kursor paling tebal; di luar radius kembali ke min. Tanpa kursor, wave bernapas.
  const draw = (now: number) => {
    frame = 0;
    const span = max - min;
    const near = pointer
      ? letters.map((el) => {
          const rect = el.getBoundingClientRect();
          const distance = Math.hypot(
            pointer!.x - (rect.left + rect.width / 2),
            pointer!.y - (rect.top + rect.height / 2),
          );
          return Math.min(distance / radius, 1);
        })
      : [];
    if (near.some((t) => t < 1))
      return set(
        near.map((t) =>
          Math.round(min + span * (0.5 + 0.5 * Math.cos(Math.PI * t))),
        ),
      );
    if (!wave) return set(letters.map(() => min));
    set(
      letters.map((_, i) =>
        Math.round(
          min +
            span *
              (0.5 -
                0.5 *
                  Math.cos((now / WAVE_PERIOD) * 2 * Math.PI - i * WAVE_PHASE)),
        ),
      ),
    );
    if (visible) frame = requestAnimationFrame(draw);
  };
  const schedule = () => {
    if (!frame && visible) frame = requestAnimationFrame(draw);
  };
  const move = (event: PointerEvent) => {
    pointer = { x: event.clientX, y: event.clientY };
    schedule();
  };
  const out = () => {
    pointer = undefined;
    schedule();
  };

  const observer =
    typeof IntersectionObserver === "undefined"
      ? undefined
      : new IntersectionObserver((entries) => {
          visible = entries.some((entry) => entry.isIntersecting);
          cancelAnimationFrame(frame);
          frame = 0;
          schedule();
        });
  visible = !observer;
  observer?.observe(element);
  schedule();
  addEventListener("pointermove", move);
  document.documentElement.addEventListener("pointerleave", out);
  cleanup = () => {
    observer?.disconnect();
    cancelAnimationFrame(frame);
    removeEventListener("pointermove", move);
    document.documentElement.removeEventListener("pointerleave", out);
    set(letters.map(() => min));
  };
}

onMounted(start);
watch(
  () => [props.text, props.radius, props.min, props.max, props.wave],
  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"
      :style="weight(props.min)"
      >{{ char }}</span
    ></span
  >
</template>
```

```vue
<template>
  <p class="text-6xl">
    <VariableWeightText text="Kedekatan" :radius="100" :min="200" :max="900" />
  </p>
  <VariableWeightText text="markasui" wave class="text-7xl" />
</template>
```

### Svelte

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

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

  const root = "inline";
  const letter =
    "transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none";

  /** One breath of the wave (ms) and the phase step between letters (radians). */
  const WAVE_PERIOD = 2400;
  const WAVE_PHASE = 0.45;

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

  /** Sets the weight through the wght axis of a variable font, with font-weight as a fallback. */
  const setWeight = (el: HTMLElement, value: number) => {
    el.style.fontVariationSettings = `'wght' ${value}`;
    el.style.fontWeight = String(value);
  };

  type Props = Omit<HTMLAttributes<HTMLSpanElement>, "children"> & {
    text: string;
    radius?: number;
    min?: number;
    max?: number;
    wave?: boolean;
  };

  let {
    text,
    radius = 120,
    min = 300,
    max = 800,
    wave = false,
    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 = { radius, min, max, wave, count: chars.length };
    if (!element || reducedMotion()) return;
    const host = element;
    const letters = [...host.querySelectorAll<HTMLElement>("[data-letter]")];
    const set = (values: number[]) =>
      letters.forEach((el, i) => setWeight(el, values[i]!));
    let pointer: { x: number; y: number } | undefined;
    let visible = false;
    let frame = 0;

    // The letter closest to the cursor is boldest; outside the radius it goes back to min. Without a cursor, wave breathes.
    const draw = (now: number) => {
      frame = 0;
      const span = options.max - options.min;
      const near = pointer
        ? letters.map((el) => {
            const rect = el.getBoundingClientRect();
            const distance = Math.hypot(
              pointer!.x - (rect.left + rect.width / 2),
              pointer!.y - (rect.top + rect.height / 2),
            );
            return Math.min(distance / options.radius, 1);
          })
        : [];
      if (near.some((t) => t < 1))
        return set(
          near.map((t) =>
            Math.round(
              options.min + span * (0.5 + 0.5 * Math.cos(Math.PI * t)),
            ),
          ),
        );
      if (!options.wave) return set(letters.map(() => options.min));
      set(
        letters.map((_, i) =>
          Math.round(
            options.min +
              span *
                (0.5 -
                  0.5 *
                    Math.cos(
                      (now / WAVE_PERIOD) * 2 * Math.PI - i * WAVE_PHASE,
                    )),
          ),
        ),
      );
      if (visible) frame = requestAnimationFrame(draw);
    };
    const schedule = () => {
      if (!frame && visible) frame = requestAnimationFrame(draw);
    };
    const move = (event: PointerEvent) => {
      pointer = { x: event.clientX, y: event.clientY };
      schedule();
    };
    const out = () => {
      pointer = undefined;
      schedule();
    };

    const observer =
      typeof IntersectionObserver === "undefined"
        ? undefined
        : new IntersectionObserver((entries) => {
            visible = entries.some((entry) => entry.isIntersecting);
            cancelAnimationFrame(frame);
            frame = 0;
            schedule();
          });
    visible = !observer;
    observer?.observe(host);
    schedule();
    addEventListener("pointermove", move);
    document.documentElement.addEventListener("pointerleave", out);
    return () => {
      observer?.disconnect();
      cancelAnimationFrame(frame);
      removeEventListener("pointermove", move);
      document.documentElement.removeEventListener("pointerleave", out);
      set(letters.map(() => options.min));
    };
  });
</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}
      style:font-variation-settings="'wght' {min}"
      style:font-weight={min}>{char}</span
    >{/each}</span
>
```

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

<p class="text-6xl">
  <VariableWeightText text="Kedekatan" radius={100} min={200} max={900} />
</p>
<VariableWeightText text="markasui" wave class="text-7xl" />
```

### Astro

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

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

const root = "inline";
const letter =
  "transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none";

type Props = Omit<HTMLAttributes<"span">, "children"> & {
  text: string;
  radius?: number;
  min?: number;
  max?: number;
  wave?: boolean;
};

const {
  text,
  radius = 120,
  min = 300,
  max = 800,
  wave = false,
  class: className,
  ...rest
} = Astro.props;
// Starting weight through the wght axis of a variable font, with font-weight as a fallback.
const restWeight = `font-variation-settings: 'wght' ${Number(min)}; font-weight: ${Number(min)}`;
---

<markas-variable-weight-text class="contents" data-radius={radius} data-min={min} data-max={max} data-wave={String(wave)}><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} style={restWeight}>{char}</span>)}</span></markas-variable-weight-text>

<script>
  /** One breath of the wave (ms) and the phase step between letters (radians). */
  const WAVE_PERIOD = 2400;
  const WAVE_PHASE = 0.45;

  /** Sets the weight through the wght axis of a variable font, with font-weight as a fallback. */
  const setWeight = (el: HTMLElement, value: number) => {
    el.style.fontVariationSettings = `'wght' ${value}`;
    el.style.fontWeight = String(value);
  };

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

    connectedCallback() {
      const element = this.firstElementChild;
      if (!element || matchMedia("(prefers-reduced-motion: reduce)").matches)
        return;
      const radius = Number(this.dataset.radius);
      const min = Number(this.dataset.min);
      const span = Number(this.dataset.max) - min;
      const wave = this.dataset.wave === "true";
      const letters = [
        ...element.querySelectorAll<HTMLElement>("[data-letter]"),
      ];
      const set = (values: number[]) =>
        letters.forEach((el, i) => setWeight(el, values[i]!));
      let pointer: { x: number; y: number } | undefined;
      let visible = false;
      let frame = 0;

      // The letter closest to the cursor is boldest; outside the radius it goes back to min. Without a cursor, wave breathes.
      const draw = (now: number) => {
        frame = 0;
        const near = pointer
          ? letters.map((el) => {
              const rect = el.getBoundingClientRect();
              const distance = Math.hypot(
                pointer!.x - (rect.left + rect.width / 2),
                pointer!.y - (rect.top + rect.height / 2),
              );
              return Math.min(distance / radius, 1);
            })
          : [];
        if (near.some((t) => t < 1))
          return set(
            near.map((t) =>
              Math.round(min + span * (0.5 + 0.5 * Math.cos(Math.PI * t))),
            ),
          );
        if (!wave) return set(letters.map(() => min));
        set(
          letters.map((_, i) =>
            Math.round(
              min +
                span *
                  (0.5 -
                    0.5 *
                      Math.cos(
                        (now / WAVE_PERIOD) * 2 * Math.PI - i * WAVE_PHASE,
                      )),
            ),
          ),
        );
        if (visible) frame = requestAnimationFrame(draw);
      };
      const schedule = () => {
        if (!frame && visible) frame = requestAnimationFrame(draw);
      };
      const move = (event: PointerEvent) => {
        pointer = { x: event.clientX, y: event.clientY };
        schedule();
      };
      const out = () => {
        pointer = undefined;
        schedule();
      };

      const observer =
        typeof IntersectionObserver === "undefined"
          ? undefined
          : new IntersectionObserver((entries) => {
              visible = entries.some((entry) => entry.isIntersecting);
              cancelAnimationFrame(frame);
              frame = 0;
              schedule();
            });
      visible = !observer;
      observer?.observe(element);
      schedule();
      addEventListener("pointermove", move);
      document.documentElement.addEventListener("pointerleave", out);
      this.cleanup = () => {
        observer?.disconnect();
        cancelAnimationFrame(frame);
        removeEventListener("pointermove", move);
        document.documentElement.removeEventListener("pointerleave", out);
        set(letters.map(() => min));
      };
    }

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

  if (!customElements.get("markas-variable-weight-text"))
    customElements.define(
      "markas-variable-weight-text",
      MarkasVariableWeightText,
    );
</script>
```

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

<p class="text-6xl">
  <VariableWeightText text="Kedekatan" radius={100} min={200} max={900} />
</p>
<VariableWeightText text="markasui" wave class="text-7xl" />
```

### Angular

Simpan di `src/app/markas/variable-weight-text.component.ts`. Tanpa dependensi tambahan.

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

const root = "inline";
const letter =
  "transition-[font-variation-settings,font-weight] duration-200 ease-out motion-reduce:transition-none";

/** One breath of the wave (ms) and the phase step between letters (radians). */
const WAVE_PERIOD = 2400;
const WAVE_PHASE = 0.45;

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

/** Sets the weight through the wght axis of a variable font, with font-weight as a fallback. */
const setWeight = (el: HTMLElement, value: number) => {
  el.style.fontVariationSettings = `'wght' ${value}`;
  el.style.fontWeight = String(value);
};

type WeightOptions = {
  radius: number;
  min: number;
  max: number;
  wave: boolean;
};

/** Follows the pointer (and runs the wave) on the letters inside `element`. Returns a stop function. */
function startWeights(element: HTMLElement, options: WeightOptions) {
  const { radius, min, max, wave } = options;
  const letters = [...element.querySelectorAll<HTMLElement>("[data-letter]")];
  const set = (values: number[]) =>
    letters.forEach((el, i) => setWeight(el, values[i]!));
  let pointer: { x: number; y: number } | undefined;
  let visible = false;
  let frame = 0;

  // The letter closest to the cursor is boldest; outside the radius it goes back to min. Without a cursor, wave breathes.
  const draw = (now: number) => {
    frame = 0;
    const span = max - min;
    const near = pointer
      ? letters.map((el) => {
          const rect = el.getBoundingClientRect();
          const distance = Math.hypot(
            pointer!.x - (rect.left + rect.width / 2),
            pointer!.y - (rect.top + rect.height / 2),
          );
          return Math.min(distance / radius, 1);
        })
      : [];
    if (near.some((t) => t < 1))
      return set(
        near.map((t) =>
          Math.round(min + span * (0.5 + 0.5 * Math.cos(Math.PI * t))),
        ),
      );
    if (!wave) return set(letters.map(() => min));
    set(
      letters.map((_, i) =>
        Math.round(
          min +
            span *
              (0.5 -
                0.5 *
                  Math.cos((now / WAVE_PERIOD) * 2 * Math.PI - i * WAVE_PHASE)),
        ),
      ),
    );
    if (visible) frame = requestAnimationFrame(draw);
  };
  const schedule = () => {
    if (!frame && visible) frame = requestAnimationFrame(draw);
  };
  const move = (event: PointerEvent) => {
    pointer = { x: event.clientX, y: event.clientY };
    schedule();
  };
  const out = () => {
    pointer = undefined;
    schedule();
  };

  const observer =
    typeof IntersectionObserver === "undefined"
      ? undefined
      : new IntersectionObserver((entries) => {
          visible = entries.some((entry) => entry.isIntersecting);
          cancelAnimationFrame(frame);
          frame = 0;
          schedule();
        });
  visible = !observer;
  observer?.observe(element);
  schedule();
  addEventListener("pointermove", move);
  document.documentElement.addEventListener("pointerleave", out);
  return () => {
    observer?.disconnect();
    cancelAnimationFrame(frame);
    removeEventListener("pointermove", move);
    document.documentElement.removeEventListener("pointerleave", out);
    set(letters.map(() => min));
  };
}

/** Attribute selector on a span, so the user's class and aria-* stay on the root. */
@Component({
  selector: "span[markas-variable-weight-text]",
  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"
        [style.font-variation-settings]="restSettings()"
        [style.font-weight]="min()"
        >{{ char }}</span
      >
    }`,
})
export class VariableWeightText {
  readonly text = input.required<string>();
  readonly radius = input(120, { transform: numberAttribute });
  readonly min = input(300, { transform: numberAttribute });
  readonly max = input(800, { transform: numberAttribute });
  readonly wave = input(false, { transform: booleanAttribute });

  protected readonly root = root;
  protected readonly letter = letter;
  protected readonly chars = computed(() => Array.from(this.text()));
  protected readonly restSettings = computed(() => `'wght' ${this.min()}`);
  private readonly host = inject<ElementRef<HTMLElement>>(ElementRef);

  constructor() {
    afterRenderEffect((onCleanup) => {
      const options = {
        radius: this.radius(),
        min: this.min(),
        max: this.max(),
        wave: this.wave(),
      };
      this.chars();
      if (reducedMotion()) return;
      onCleanup(startWeights(this.host.nativeElement, options));
    });
  }
}
```

```ts
import { Component } from "@angular/core";
import { VariableWeightText } from "./markas/variable-weight-text.component";

@Component({
  selector: "app-wordmark",
  imports: [VariableWeightText],
  template: `
    <p class="text-6xl">
      <span
        markas-variable-weight-text
        text="Kedekatan"
        radius="100"
        min="200"
        max="900"
      ></span>
    </p>
    <span
      markas-variable-weight-text
      text="markasui"
      wave
      class="text-7xl"
    ></span>
  `,
})
export class Wordmark {}
```

Angular memakai attribute selector pada span: `<span markas-variable-weight-text>`.

## Props

| Nama | Tipe | Default | Keterangan |
| --- | --- | --- | --- |
| `text` | `string` | - | Teksnya. Screen reader membacanya sekali secara utuh. |
| `radius` | `number` | 120 | Jarak dalam piksel dari kursor tempat huruf menebal. |
| `min` | `number` | 300 | Berat saat diam dan di luar radius. |
| `max` | `number` | 800 | Berat huruf tepat di bawah kursor. |
| `wave` | `boolean` | false | Saat kursor jauh, gelombang berat berjalan melewati huruf. Berhenti saat di luar layar. |

## Aksesibilitas

- Screen reader membaca teks utuh sekali dari salinan tersembunyi; span huruf memakai aria-hidden.
- Efeknya dekoratif dan tidak butuh interaksi; teks tetap terbaca di setiap berat.
- Dengan reduced motion, huruf tetap di berat min dan gelombang tidak berjalan.

## Catatan

- Butuh font variabel dengan sumbu `wght`, misalnya Inter, Geist, Recursive, atau font sistem di macOS dan iOS. Dengan font statis, berat melompat di antara berat yang dimuat.
- Setiap huruf memasang `font-variation-settings: 'wght' n` dan `font-weight` sebagai cadangan. Huruf di bawah kursor mendapat `max`; huruf di luar `radius` kembali ke `min`, yang juga berat saat diam.
- `wave` menjalankan gelombang berat yang bernapas selama kursor jauh. Berhenti saat teks di luar layar dan saat tab tersembunyi.
- Screen reader membaca teks sekali. Dengan reduced motion, huruf tetap di `min`. Versi Blade butuh Alpine.js.
