02上限を超えると揺れて止めるチップ入力

<main class="stage">
<div class="tm is-demo" id="tm">
  <div class="tm__row" id="tmRow">
    <input type="text" class="tm__input" id="tmInput" aria-label="タグ入力、上限に達すると枠が揺れる" placeholder="タグ入力">
    <button type="button" class="tm__add" id="tmAdd" aria-label="タグを追加">+</button>
  </div>
  <p class="tm__meta">タグ<b id="tmCount">0</b> / <b id="tmMax">5</b><span class="tm__warn" id="tmWarn" hidden>・上限到達</span></p>
  <p class="tm__sr" role="alert" id="tmLive"></p>
</div>
</main>

@use "../../../../site/static/demo-tokens" as *;

// 계산 겹: block() 이 count() 를 MAX_COUNT 와 비교해 이미 한도면 칩을 만들지 않고
// .tm__row--shake 을 다시 건다(reflow 로 재생 보장). 진폭이 줄어드는 5단 스프링 오프셋으로
// 감쇠 진동을 흉내낸다 — 단순 좌우 2단 흔들림이 아니다.
@include stage($stage-yellow);

.tm { width: min(100%, 300px); display: flex; flex-direction: column; gap: $sp-2; }
.tm__row {
  display: flex; flex-wrap: wrap; align-items: center; gap: $sp-2;
  background: rgba($subject-ink, .06); border: 1px solid rgba($subject-ink, .18);
  border-radius: $r-control; padding: $sp-2 $sp-3;
}
.tm__row--shake { animation: tmShake $dur-enter $ease-spring 1; }
.tm__input {
  flex: 1 1 auto; min-width: 0; border: none; background: transparent; color: $subject-ink;
  font-size: 12px; outline: none;
}
.tm__input::placeholder { color: rgba($subject-ink, .55); }
.tm__add {
  flex: 0 0 auto; width: 26px; height: 26px; border: none; border-radius: 50%;
  background: $subject-ink; color: $stage-yellow; font-size: 15px; line-height: 1; cursor: pointer;
  display: grid; place-items: center; transition: transform $dur-instant $ease-out;
}
.tm__add:active { transform: scale(.88); }
.tm__add:focus-visible { outline: 2px solid $subject-ink; outline-offset: 2px; }

.tm__chip {
  display: inline-flex; align-items: center; gap: $sp-1; height: 24px; padding: 0 $sp-1 0 $sp-3;
  background: $subject-ink; color: $stage-yellow; border-radius: $r-pill;
  font-size: 12px; font-weight: 700; white-space: nowrap;
  transform: scale(1); opacity: 1; transition: transform $dur-quick $ease-pop, opacity $dur-quick $ease-out;
}
.tm__chip--enter { transform: scale(.6); opacity: 0; }
.tm__chipX {
  width: 16px; height: 16px; border: none; border-radius: 50%; background: rgba($stage-yellow, .28);
  color: $stage-yellow; font-size: 11px; line-height: 1; cursor: pointer; display: grid; place-items: center;
}
.tm__chipX:focus-visible { outline: 2px solid $subject-ink; outline-offset: 2px; }

.tm__meta { margin: 0; font-size: 11px; color: rgba($subject-ink, .72); }
.tm__meta b { color: $subject-ink; font-weight: 700; }
.tm__warn { color: $error; font-weight: 700; }
.tm__sr {
  position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); margin: -1px; padding: 0; border: 0;
}

// 감쇠 스프링: 진폭이 8→5→3→1→0px 로 줄며 좌우로 흔들린다(단순 2단 shake 가 아니다)
@keyframes tmShake {
  0%   { transform: translateX(0); }
  8%   { transform: translateX(-8px); }
  18%  { transform: translateX(7px); }
  30%  { transform: translateX(-5px); }
  44%  { transform: translateX(4px); }
  58%  { transform: translateX(-3px); }
  72%  { transform: translateX(2px); }
  86%  { transform: translateX(-1px); }
  100% { transform: translateX(0); }
}

@media (max-width: 340px) {
  .tm { width: 100%; }
  .tm__row { padding: $sp-2; }
}

@media (prefers-reduced-motion: reduce) {
  .tm__row--shake { animation: none; }
  .tm__chip { transition: none; }
  .tm__add { transition: none; }
}

html, body {
  margin: 0;
  overflow: hidden;
}

.stage {
  box-sizing: border-box;
  min-height: 100vh;
  display: grid;
  place-items: center;
  margin: 0;
  background: #ffd23f;
  font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
  padding: clamp(8px, 4vw, 24px);
}

.tm {
  width: min(100%, 300px);
  display: flex;
  flex-direction: column;
  gap: 8px;
}

.tm__row {
  display: flex;
  flex-wrap: wrap;
  align-items: center;
  gap: 8px;
  background: rgba(23, 20, 26, 0.06);
  border: 1px solid rgba(23, 20, 26, 0.18);
  border-radius: 12px;
  padding: 8px 12px;
}

.tm__row--shake {
  animation: tmShake 600ms cubic-bezier(0.2, 0.8, 0.2, 1) 1;
}

.tm__input {
  flex: 1 1 auto;
  min-width: 0;
  border: none;
  background: transparent;
  color: #17141a;
  font-size: 12px;
  outline: none;
}

.tm__input::placeholder {
  color: rgba(23, 20, 26, 0.55);
}

.tm__add {
  flex: 0 0 auto;
  width: 26px;
  height: 26px;
  border: none;
  border-radius: 50%;
  background: #17141a;
  color: #ffd23f;
  font-size: 15px;
  line-height: 1;
  cursor: pointer;
  display: grid;
  place-items: center;
  transition: transform 140ms ease-out;
}

.tm__add:active {
  transform: scale(0.88);
}

.tm__add:focus-visible {
  outline: 2px solid #17141a;
  outline-offset: 2px;
}

.tm__chip {
  display: inline-flex;
  align-items: center;
  gap: 4px;
  height: 24px;
  padding: 0 4px 0 12px;
  background: #17141a;
  color: #ffd23f;
  border-radius: 999px;
  font-size: 12px;
  font-weight: 700;
  white-space: nowrap;
  transform: scale(1);
  opacity: 1;
  transition: transform 220ms cubic-bezier(0.2, 1.4, 0.4, 1), opacity 220ms ease-out;
}

.tm__chip--enter {
  transform: scale(0.6);
  opacity: 0;
}

.tm__chipX {
  width: 16px;
  height: 16px;
  border: none;
  border-radius: 50%;
  background: rgba(255, 210, 63, 0.28);
  color: #ffd23f;
  font-size: 11px;
  line-height: 1;
  cursor: pointer;
  display: grid;
  place-items: center;
}

.tm__chipX:focus-visible {
  outline: 2px solid #17141a;
  outline-offset: 2px;
}

.tm__meta {
  margin: 0;
  font-size: 11px;
  color: rgba(23, 20, 26, 0.72);
}

.tm__meta b {
  color: #17141a;
  font-weight: 700;
}

.tm__warn {
  color: #c2361a;
  font-weight: 700;
}

.tm__sr {
  position: absolute;
  width: 1px;
  height: 1px;
  overflow: hidden;
  clip: rect(0 0 0 0);
  margin: -1px;
  padding: 0;
  border: 0;
}

@keyframes tmShake {
  0% {
    transform: translateX(0);
  }
  8% {
    transform: translateX(-8px);
  }
  18% {
    transform: translateX(7px);
  }
  30% {
    transform: translateX(-5px);
  }
  44% {
    transform: translateX(4px);
  }
  58% {
    transform: translateX(-3px);
  }
  72% {
    transform: translateX(2px);
  }
  86% {
    transform: translateX(-1px);
  }
  100% {
    transform: translateX(0);
  }
}
@media (max-width: 340px) {
  .tm {
    width: 100%;
  }
  .tm__row {
    padding: 8px;
  }
}
@media (prefers-reduced-motion: reduce) {
  .tm__row--shake {
    animation: none;
  }
  .tm__chip {
    transition: none;
  }
  .tm__add {
    transition: none;
  }
}

(function () {
  var MAX_COUNT = 5; // 계산 겹 상수: 이 개수와 매번 비교해 한도를 판정한다
  var WORDS = ['やること', '進行中', '完了', '保留', '緊急'];
  var OVER_WORD = '確認';
  var ADD_MS = 180, PAUSE_MS = 900;
  var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;

  var root = document.getElementById('tm');
  var row = document.getElementById('tmRow');
  var input = document.getElementById('tmInput');
  var addBtn = document.getElementById('tmAdd');
  var countEl = document.getElementById('tmCount');
  var warnEl = document.getElementById('tmWarn');
  var live = document.getElementById('tmLive');
  var seq = 0;

  function count() { return row.querySelectorAll('.tm__chip').length; }

  function render() {
    countEl.textContent = count();
    warnEl.hidden = count() < MAX_COUNT;
  }

  function human() { if (root.classList.contains('is-demo')) root.classList.remove('is-demo'); }

  function block() {
    // 계산 겹: 개수를 MAX_COUNT 와 비교해 이미 한도라면 칩을 만들지 않고 스프링 흔들림만 재생한다
    row.classList.remove('tm__row--shake');
    void row.offsetWidth; // 리플로우 — 같은 클래스를 다시 걸어도 애니메이션이 재생되게
    row.classList.add('tm__row--shake');
    live.textContent = 'タグ' + MAX_COUNT + '個で上限到達';
    if (reduce) render();
  }

  function add(text) {
    if (!text) return;
    if (count() >= MAX_COUNT) { block(); return; }
    seq++;
    var chip = document.createElement('span');
    chip.className = 'tm__chip tm__chip--enter';
    chip.id = 'tmChip' + seq;
    chip.innerHTML = '<span class="tm__chipText"></span><button type="button" class="tm__chipX">×</button>';
    chip.querySelector('.tm__chipText').textContent = text;
    chip.querySelector('.tm__chipX').setAttribute('aria-label', 'タグ削除: ' + text);
    chip.querySelector('.tm__chipX').addEventListener('click', function () { human(); chip.remove(); render(); });
    row.insertBefore(chip, input);
    requestAnimationFrame(function () { chip.classList.remove('tm__chip--enter'); });
    render();
    live.textContent = text + ' 追加・タグ ' + count() + '個';
  }

  addBtn.addEventListener('click', function () { human(); add(input.value.trim()); input.value = ''; });
  input.addEventListener('keydown', function (e) {
    if (e.key === 'Enter' && input.value.trim()) { human(); add(input.value.trim()); input.value = ''; }
  });

  var timer = 0;
  function schedule(fn, ms) { timer = window.setTimeout(fn, ms); }

  function loop(i) {
    if (!root.classList.contains('is-demo')) return;
    if (i < WORDS.length) {
      add(WORDS[i]);
      schedule(function () { loop(i + 1); }, ADD_MS);
    } else if (i === WORDS.length) {
      add(OVER_WORD); // 한도에 닿아 block() 이 대신 실행된다
      schedule(function () { loop(i + 1); }, PAUSE_MS);
    } else {
      row.querySelectorAll('.tm__chip').forEach(function (c) { c.remove(); });
      render();
      schedule(function () { loop(0); }, ADD_MS);
    }
  }

  render();
  if (!reduce) {
    schedule(function () { loop(0); }, 320);
  } else {
    root.classList.remove('is-demo');
  }
})();

// TagMaxCountShakeBlock — vanilla 판(run/397/demo/02-tag-input-max-count-shake-block/index.html) 의 React 포트.
// block() 이 count 를 MAX_COUNT 와 비교해 이미 한도면 칩을 만들지 않고 감쇠 스프링 shake 클래스를 다시 건다
// (키를 바꿔 리마운트시켜 CSS 애니메이션이 매번 재생되게 한다 — reflow 트릭의 React 버전).
import { useEffect, useRef, useState } from "react";
import styles from "./TagMaxCountShakeBlock.module.scss";

type Box<T> = { current: T };
type ChangeEvt = { target: { value: string } };
type KeyEvt = { key: string };

const MAX_COUNT = 5; // 계산 겹 상수: 이 개수와 매번 비교해 한도를 판정한다
const WORDS = ["할일", "진행중", "완료", "보류", "긴급"];
const OVER_WORD = "확인";
const ADD_MS = 180, PAUSE_MS = 900;

type Chip = { id: number; text: string; entering: boolean };

export default function TagMaxCountShakeBlock() {
  const timerRef = useRef(0) as unknown as Box<number>;
  const seqRef = useRef(1) as unknown as Box<number>;
  const shakeSeqRef = useRef(0) as unknown as Box<number>;
  const isDemoRef = useRef(true) as unknown as Box<boolean>;

  const [chips, setChips] = useState<Chip[]>([]);
  const [draft, setDraft] = useState("");
  const [shakeKey, setShakeKey] = useState(0);
  const [warn, setWarn] = useState(false);
  const [isDemo, setIsDemo] = useState(true);
  const [live, setLive] = useState("");

  function human() {
    if (isDemoRef.current) { isDemoRef.current = false; setIsDemo(false); }
  }

  function block() {
    // 계산 겹: 현재 개수를 MAX_COUNT 와 비교해 이미 한도라면 칩을 만들지 않고 스프링 흔들림만 재생한다
    shakeSeqRef.current++;
    setShakeKey(shakeSeqRef.current);
    setLive("태그 " + MAX_COUNT + "개 한도에 닿았다");
  }

  function add(text: string) {
    if (!text) return;
    setChips((cs) => {
      if (cs.length >= MAX_COUNT) { block(); return cs; }
      const id = seqRef.current++;
      setLive(text + " 추가 · 태그 " + (cs.length + 1) + "개");
      window.setTimeout(() => {
        setChips((cs2) => cs2.map((c) => (c.id === id ? { ...c, entering: false } : c)));
      }, 20);
      return [...cs, { id, text, entering: true }];
    });
  }

  function removeChip(id: number) {
    human();
    setChips((cs) => cs.filter((c) => c.id !== id));
  }

  useEffect(() => {
    setWarn(chips.length >= MAX_COUNT);
  }, [chips.length]);

  useEffect(() => {
    const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;

    function loop(i: number) {
      if (!isDemoRef.current) return;
      if (i < WORDS.length) {
        add(WORDS[i]);
        timerRef.current = window.setTimeout(() => loop(i + 1), ADD_MS);
      } else if (i === WORDS.length) {
        add(OVER_WORD);
        timerRef.current = window.setTimeout(() => loop(i + 1), PAUSE_MS);
      } else {
        setChips([]);
        timerRef.current = window.setTimeout(() => loop(0), ADD_MS);
      }
    }

    if (!reduce) {
      timerRef.current = window.setTimeout(() => loop(0), 320);
    } else {
      isDemoRef.current = false;
      setIsDemo(false);
    }
    return () => window.clearTimeout(timerRef.current);
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  function onAdd() { human(); add(draft.trim()); setDraft(""); }
  function onInput(e: ChangeEvt) { setDraft(e.target.value); }
  function onKeyDown(e: KeyEvt) {
    if (e.key === "Enter" && draft.trim()) { human(); add(draft.trim()); setDraft(""); }
  }

  return (
    <main className={styles.stage}>
      <div className={styles.tm + " " + (isDemo ? styles.isDemo : "")}>
        <div key={shakeKey} className={styles.row + (shakeKey ? " " + styles.rowShake : "")}>
          {chips.map((c) => (
            <span key={c.id} className={styles.chip + (c.entering ? " " + styles.chipEnter : "")}>
              <span>{c.text}</span>
              <button type="button" className={styles.chipX} aria-label={"태그 삭제: " + c.text} onClick={() => removeChip(c.id)}>×</button>
            </span>
          ))}
          <input
            type="text" className={styles.input} aria-label="태그 입력, 한도에 닿으면 칸이 흔들린다"
            placeholder="태그 입력" value={draft} onChange={onInput} onKeyDown={onKeyDown}
          />
          <button type="button" className={styles.add} aria-label="태그 추가" onClick={onAdd}>+</button>
        </div>
        <p className={styles.meta}>
          태그 <b>{chips.length}</b> / <b>{MAX_COUNT}</b>
          {warn ? <span className={styles.warn}> · 한도 도달</span> : null}
        </p>
        <p className={styles.sr} role="alert">{live}</p>
      </div>
    </main>
  );
}