GODRICH
#css애니메이션#버튼#로딩#전환효과#스크롤#대시보드#실전ui#디자인트렌드

sortable js 없이 드래그 정렬 리스트 9종 — 순서 바꾸기 FLIP 복붙

드래그 정렬 리스트는 마법이 아니라 두 개의 계산이다 — 드래그 중인 항목의 중심점이 이웃의 중간점을 지나는 순간 나머지 항목이 밀리고, 놓는 순간 이동 거리를 재서 역변환으로 되감는 FLIP 계산이 순서 바꾸기 전체를 라이브러리 없이 움직인다.

zip 구성과 여는 법

아홉 장면을 이 순서로 놓은 이유는 계산이 쌓이는 방향이다. 01 이 재배치 전후 위치를 재는 기본 FLIP 을 깔고, 02 가 스왑이 일어나는 순간을 값으로 정하며, 03·04 가 그 판정을 2열 그리드와 칸반 컬럼으로 확장한다. 05 는 목록이 화면보다 길어질 때, 06 은 드래그 시작 조건을 손잡이로 좁힐 때, 07 은 바뀐 순서를 다음 방문까지 기억할 때, 08 은 손맛에 관성을 얹을 때, 09 는 포인터 없이 키보드만으로 같은 짓을 할 때 각각 필요한 계산 한 겹이다. 이 순서대로 읽으면 계산이 쌓이는 걸 확인할 수 있다.

아홉 장면의 표에는 이 페이지에서 바로 끌어 볼 수 있는 라이브 데모가 들어 있다. 각 장면의 움직임은 결정적 좌표·키 입력을 주입하는 자동 시연으로 재생되는데, 화면 밖 코드는 사람 손으로 잡는 경로와 같은 핸들러를 공유하므로 이 글의 판정식은 실전 그대로다.

아홉 장면의 측정값

숫자는 도구/demo.py 가 480×300 무대를 24장 찍고 이웃한 두 장의 차 23개로 잰 렌더 실측이며 측정 시각은 2026-11-16 00:38~00:39 이다. 측정 장면의 움직임은 전부 주입 시연이다.

항목 장면 누적면적 강도 움직인 프레임
01 기본 세로 FLIP 31.6% 116.0 23/23
02 임계 스왑 14.6% 118.4 23/23
03 그리드 2열 16.7% 110.1 23/23
04 칸반 축 전환 15.4% 112.0 23/23
05 오토스크롤 곡선 13.0% 118.9 23/23
06 핸들 전용 22.5% 110.1 23/23
07 순서 저장 21.6% 112.5 23/23
08 고스트 틸트 28.6% 107.2 23/23
09 키보드 대체 3.5% 116.2 23/23

누적면적이 가장 큰 01 은 다섯 행 전체가 한 번에 밀리는 판이라 그렇고, 08 은 고스트의 기울기와 그림자가 속도에 비례해 계속 변해서다. 09 이 3.5% 로 가장 작은데 한 칸 교환이 조용히 반복되는 키보드 판이라 정상이고, 화면이 조용한 만큼 스크린리더 문장과 포커스 이동이 그 자리를 채운다. 아홉 장면 모두 23/23 — 캡처 창 안에서는 매 프레임 무언가가 움직였다.

자리바꿈은 언제 일어나는가 — 중심점 통과 판정이 임계값이고 그 값이 손맛을 결정한다

사람의 눈이 잡은 카드를 따라가는 동안 브라우저가 정하는 것은 매 순간 하나다 — 잡은 카드의 중심 y 가 지금 몇 번 슬롯에 있는가. 슬롯 번호는 나눗셈 한 번으로 나온다.

드래그 중인 카드의 중심 y 를 슬롯 높이로 나누면 소수점이 붙은 슬롯 번호가 나온다 — 1.4칸째, 1.6칸째 이런 식이다. 이 소수를 반올림해 목표 슬롯을 정하고, 지금 슬롯과 달라지면 배열을 splice 로 갈아 끼운다. 여기서 임계값이 나온다. 원 슬롯과의 거리가 0.5칸을 넘어야 바꿀 것인가, 0.85칸을 넘어야 할 것인가. 02 장면이 이 값 하나로 손맛이 어떻게 달라지는지 보여 준다.

나머지 항목은 어떻게 밀리는가 — FLIP 은 첫 측정(first)·마지막 측정(last)·역변환(invert)·재생(play)의 넉 단계 계산이다

배열이 바뀌면 나머지 카드가 제자리로 미끄러져 들어가는데, 이 움직임이 FLIP 계산이다. First 로 재배치 전 위치를 재고, Mutate 로 DOM 순서를 바꾸고, Last 로 다시 재고, Invert 로 두 측정의 차를 카드에 역방향 transform 으로 걸어 원래 있던 자리에 보이게 둔 다음, Play 로 그 transform 을 0 까지 되감는다. 카드는 실제로는 이미 새 자리에 있는데 눈에는 옛 자리에서 새 자리로 이동하는 것처럼 보인다.

재감는 속도는 easeOutCubic — 남은 거리의 세제곱근 꼴로 움직여 시작이 빠르고 끝에서 붙는다. 정착 시간은 FLIP_SETTLE_MS 520ms 다. 라이브러리 없이 재생을 결정적으로 하려면 Date 나 Math.random 을 쓰지 않고 CSS 시계 애니메이션의 currentTime 을 읽어 시간을 공급하면, 렌더를 다시 돌려도 같은 프레임이 나온다.

한 가지 좌표 보정이 붙는다. 데모 무대는 화면 폭에 맞춰 scale(k) 로 축소되어 있어서 getBoundingClientRect 값은 무대 좌표의 k 배다. 그래서 두 측정의 차를 k 로 나눠 무대 좌표로 환산하고, 재생 배율 FLIP_PLAY_SCALE 을 곱해 얼마나 멀리 나갔다 돌아오게 할지를 정한다.

01이동 거리를 재서 역변환으로 되감는 기본 세로 FLIP 리스트

재생목록·즐겨찾기처럼 항목 몇 개의 순서를 바꾸는 가장 짧은 판이다. 잡은 카드는 고스트로 떠 있고 드래그 중에는 배열만 바꾸다가, 놓는 순간 나머지 행이 역변환으로 밀려 들어간다.

이동 거리를 재서 역변환으로 되감는 기본 세로 FLIP 리스트
전체 코드 새 창에서 열기

01 · 이동 거리를 재서 역변환으로 되감는 기본 세로 FLIP 리스트 — 측정 누적면적 31.638% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

FLIP_PLAY_SCALEFLIP_SETTLE_MSgetBoundingClientRect

flipCommit 안에서 역변환이 결정된다 — 이동하지 않은 카드는 0.5px 미만 차를 transform 없이 넘기고 움직인 카드만 벡터를 받는다.

        // Last + Invert — 이동한 만큼의 역변환 벡터를 저장한다
        for (const f of first) {
            const r = f.el.getBoundingClientRect();
            const dx = (f.x - r.left) / k * playScale;
            const dy = (f.y - r.top) / k * playScale;
            if (Math.abs(dx) < 0.5 && Math.abs(dy) < 0.5) {
                f.el.style.transform = '';
                continue;
            }
            moved += 1;
            if (reduced) {
                f.el.style.transform = '';
                continue;
            }
            flipJobs.push({ el: f.el, dx: dx, dy: dy });
        }
        return moved;

02중심점이 이웃 중간점을 지나는 순간 자리를 주는 임계 스왑

할 일 목록에서 우선순위를 끌어 올리는 판이다. 카드 중심이 이웃의 중간점을 통과하는지 실시간으로 재고 통과 순간 기준선이 반짝이며 배열이 바뀐다.

중심점이 이웃 중간점을 지나는 순간 자리를 주는 임계 스왑
전체 코드 새 창에서 열기

02 · 중심점이 이웃 중간점을 지나는 순간 자리를 주는 임계 스왑 — 측정 누적면적 14.581% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

SWAP_THRESHOLD_RATIOMIDPOINT_EPS_PXpointercancel

주입 시연에서 중심점이 슬롯 중간점을 왕복 통과할 때마다 스왑 횟수가 올라가는데, 거리 판정 넉 줄이 손맛의 전부다.

            // 판정 — 중심이 어느 슬롯 중간점을 지나는지
            const slotF = (cy - 7) / (ROW_H + GAP);
            const to = clamp(Math.round(slotF), 0, 5);
            const cur = order.indexOf(0);
            // 이웃 중심과의 거리가 임계(0.5 슬롯)를 넘었는지 — 넘어야 바뀐다
            const dist = Math.abs(slotF - cur);
            const crossed = dist > SWAP_THRESHOLD_RATIO * 1;
            if (crossed && to !== cur) {
                order.splice(cur, 1);
                order.splice(to, 0, 0);
                layoutRows();
                swaps += 1;
                lastCross = f1(t) + 'ms';
            }

03행이 넘어가는 이동까지 계산하는 그리드 2열 FLIP

앱 런처 아이콘 배치처럼 2열 그리드에서 순서를 바꾸는 판이다. 이동이 옆칸이 아니라 아랫줄로 넘어가면 x 와 y 가 동시에 바뀌는데, 열과 행을 따로 계산해 하나의 역변환으로 합친다.

행이 넘어가는 이동까지 계산하는 그리드 2열 FLIP
전체 코드 새 창에서 열기

03 · 행이 넘어가는 이동까지 계산하는 그리드 2열 FLIP — 측정 누적면적 16.731% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

GRID_COLUMNSdata-indexCELL_W

중심점이 어느 칸에 가까운지는 나눗셈과 반올림으로 구한다 — 2열이라 col 은 0 아니면 1, row 는 4줄까지다.

            // 그리드 판정 — 중심점이 어느 칸에 가까운지
            const cxg = x + CELL_W / 2 - GX;
            const cyg = y + CELL_H / 2 - GY;
            const col = clamp(Math.round(cxg / (CELL_W + GAP) - 0.5), 0, 1);
            const row = clamp(Math.round(cyg / (CELL_H + GAP) - 0.5), 0, 3);
            const to2 = row * GRID_COLUMNS + col;
            const cur = order.indexOf(0);
            if (to2 !== cur) {
                order.splice(cur, 1);
                order.splice(to2, 0, 0);
                layoutCells();
            }

04세로에서 가로로 축이 바뀌는 칸반 컬럼 이동

칸반 보드에서 카드를 상태 사이(할 일 → 하는 중)로 옮기는 판이다. 세로 목록 안의 y 이동과 컬럼 사이의 x 이동이 한 FLIP 계산으로 묶여 축이 바뀌는 순간에도 화면이 끊기지 않는다.

세로에서 가로로 축이 바뀌는 칸반 컬럼 이동
전체 코드 새 창에서 열기

04 · 세로에서 가로로 축이 바뀌는 칸반 컬럼 이동 — 측정 누적면적 15.421% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

COLUMN_HIT_PADDING_PXFLIP_PLAY_SCALEaria-live

컬럼 판정은 폭보다 약간 넓은 구간에 걸쳐 있다 — 이 여유가 없으면 카드가 경계선 근처에서 좌우 컬럼 사이를 오락가락한다.

            const cxg = x0 + (x1 - x0) * u + (COL_W - 10) / 2;
            // 목표 컬럼 — 경계 ±패딩 판정
            let tc = 0;
            for (let c = 0; c < 3; c += 1) {
                if (cxg >= COL_X[c] - COLUMN_HIT_PADDING_PX && cxg <= COL_X[c] + COL_W + COLUMN_HIT_PADDING_PX) {
                    tc = c;
                    break;
                }
            }
            if (tc !== curCol || t < 500) {
                if (tc !== curCol) {
                    const card = dragCard;
                    if (card) {
                        const from = cols[curCol].cards;
                        const at = from.indexOf(card);
                        if (at >= 0) {
                            from.splice(at, 1);
                        }
                        cols[tc].cards.splice(1, 0, card);
                        layoutKanban();

놓을 때 어떻게 정착하는가 — 스프링 감속으로 FLIP 이동이 0 으로 수렴하는 시간

놓기 직후 카드가 어디까지 나갔다가 돌아오느냐는 두 값이 정한다. 정착 시간과 재생 배율이다. 정착 시간이 길면 느긋하게 들어가고, 짧으면 딱 붙는다. 재생 배율은 역변환 벡터 자체를 몇 배로 잡을지인데, 1.0 이면 측정한 거리 그대로 움직이고 1.6 이면 실제 이동보다 멀리 나갔다가 돌아온다 — 눈에는 탄력으로 읽힌다.

재생 곡선이 easeOutCubic 이라 값은 처음에 빨리 빠지고 끝에서 거의 멈춘다. 그래서 같은 정착 시간이어도 뒤 절반은 거의 머무는 셈이고, 실제로 손에 잡히는 느낌은 정착 시간의 앞 30~40% 에서 만들어진다. 데모의 일시정지 버튼으로 Play 구간을 멈춰 두면 이 앞구간이 얼마나 짧은지 직접 볼 수 있다.

05엣지 거리를 속도 곡선으로 바꾸는 오토스크롤

수십 개 항목의 긴 목록을 끌다 보면 목표 지점이 화면 밖에 있다. 포인터를 컨테이너 경계 근처에 대고 있으면 목록이 저절로 굴러가는데, 그 속도를 정규화된 경계 거리에 거듭제곱을 먹여 계산하는 판이다.

엣지 거리를 속도 곡선으로 바꾸는 오토스크롤
전체 코드 새 창에서 열기

05 · 엣지 거리를 속도 곡선으로 바꾸는 오토스크롤 — 측정 누적면적 12.953% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

AUTOSCROLL_CURVE_POWAUTOSCROLL_MAX_PX_SEDGE_ZONE_PX

속도식은 두 줄이다 — 경계까지 남은 거리의 비율 d 를 재고 최대 속도에 (1 - d)^POW 를 곱한다.

            // 엣지존 진입 여부 — 경계 거리 정규화
            const inEdge = ptrY > VIEW_Y + VIEW_H - EDGE_ZONE_PX;
            d = inEdge ? clamp((VIEW_Y + VIEW_H - ptrY) / EDGE_ZONE_PX, 0, 1) : 1;
            if (inEdge) {
                const v = AUTOSCROLL_MAX_PX_S * Math.pow(1 - d, AUTOSCROLL_CURVE_POW);
                lastV = v;
                scrollTop = clamp(scrollTop + v * (1 / 60), 0, scrollMax);
            }
            else {
                lastV = 0;
            }

06손잡이를 잡았을 때만 드래그가 되는 핸들 지정

행 안에 링크·체크박스가 있는 설정 목록에서는 드래그 시작을 손잡이로 좁힌다. pointerdown 대상이 핸들 요소를 포함하는지 closest 로 판정해 핸들일 때만 드래그를 시작하고 나머지 영역은 선택·스크롤 그대로 둔다.

손잡이를 잡았을 때만 드래그가 되는 핸들 지정
전체 코드 새 창에서 열기

06 · 손잡이를 잡았을 때만 드래그가 되는 핸들 지정 — 측정 누적면적 22.527% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

HANDLE_SELECTORuser-selecttouch-action

실제 손 경로의 시작 판정이 그대로 들어 있다 — closest 실패 조건이 두 개다.

    scWrap.addEventListener('pointerdown', function (ev) {
        const tgt = ev.target;
        // 핸들 지정 — 핸들을 눌렀을 때만 시작한다. 행 본문·링크는 그냥 둔다
        if (!tgt.closest || !tgt.closest(HANDLE_SELECTOR)) {
            return;
        }
        const card = tgt.closest('.' + cx('card'));
        if (!card) {
            return;
        }
        ev.preventDefault();
        dragIdx = Number(card.getAttribute('data-index'));
        card.setPointerCapture(ev.pointerId);
        card.style.opacity = '0.18';
        gEl = makeGhost(card, LIST_X, parseFloat(card.style.top) || slotTop(0));
    });

긴 목록에서 엣지로 가면 어떻게 되나 — 오토스크롤은 포인터와 컨테이너 경계 사이 거리를 속도로 바꾸는 곡선이다

05 장면의 곡선이 왜 거듭제곱인지 짚어 두자. 속도를 경계 거리에 그대로 비례시키면(지수 1) 포인터가 엣지존에 들어선 순간부터 이미 상당한 속도로 굴러가 사용자가 놀란다. 거듭제곱을 먹이면 경계에서 먼 쪽은 거의 멈춰 있고 가까워질수록 급격히 빨라진다 — 지수가 클수록 이 경향이 세진다. 즉 지수는 속도의 최댓값이 아니라 가속이 몰리는 위치를 정하는 값이다.

실전에서 이 곡선과 함께 쓰는 임계가 하나 더 있다 — 너무 이른 가속을 막기 위해 포인터가 엣지존에 들어온 뒤 몇 프레임은 속도를 0 으로 유지하는 지연 임계다. 데모의 시연은 0.5~1.7초 동안 엣지존에 머무는 경로를 주입해 곡선 가속을 그대로 보여 주는데, 실제 손 조작 경로에서도 같은 식이 held 상태와 함께 돈다.

순서는 어떻게 기억하는가 — 인덱스 직렬화와 pointercancel 미해제 함정

바뀐 순서를 다음 방문까지 저장하려면 DOM 이 아니라 데이터를 저장해야 한다. 07 장면이 그 최소 형태다 — 드래그가 끝날 때마다 표시 순서의 data-index 배열을 직렬화해 localStorage 에 넣고, 다음 로드에서 그 배열로 DOM 을 재배치한다.

localStorage 는 사파리 프라이빗 모드에서 예외를 던진다. try/catch 없이 쓰면 저장 한 번에 목록 전체가 죽는다.

    // localStorage 는 사파리 프라이빗 모드에서 예외를 던진다 — try/catch 필수
    function serializeOrder() {
        return rows.slice().sort(function (a, b) {
            return order.indexOf(Number(a.getAttribute('data-index'))) - order.indexOf(Number(b.getAttribute('data-index')));
        }).map(function (r) { return Number(r.getAttribute('data-index')); });
    }
    function saveOrder() {
        // data-index 재부여 + 직렬화
        const seq = serializeOrder();
        try {
            localStorage.setItem(KEY, JSON.stringify(seq));
        }
        catch (e) {
            void e;
        }
    }
    function loadOrder() {
        try {
            const raw = localStorage.getItem(KEY);
            if (!raw) {
                return null;
            }
            const v = JSON.parse(raw);
            if (Object.prototype.toString.call(v) === '[object Array]' && v.length === WISH.length) {
                return v;
            }
        }
        catch (e) {
            void e;
        }

불러오기에서 배열 길이가 항목 수와 같은지까지 확인하는 것은 저장 뒤 항목이 늘거나 줄었을 때 짝이 맞지 않는 배열로 DOM 을 배치하는 사고를 막기 위해서다. 저장 키는 dsl523.order 이고 저장 값은 [5,0,1,2,3,4] 처럼 생겼다.

07바뀐 순서를 인덱스로 직렬화해 저장하는 순서 유지

마지막 행을 세 칸 위로 끌면 저장 표시가 뜨고 이어지는 다시 읽기 페이드에서 저장된 배열로 복원된다.

바뀐 순서를 인덱스로 직렬화해 저장하는 순서 유지
전체 코드 새 창에서 열기

07 · 바뀐 순서를 인덱스로 직렬화해 저장하는 순서 유지 — 측정 누적면적 21.61% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

serializeOrderlocalStoragedata-index

저장은 놓기 정리 함수의 마지막에서 일어난다 — flipCommit 으로 재배치를 마친 뒤 saveOrder 를 부르고 칩에 저장 값을 찍는다.

        flipCommit(scWrap, function applyHand7() {
            const sorted = rows.slice().sort(function (a, b) {
                return order.indexOf(Number(a.getAttribute('data-index'))) - order.indexOf(Number(b.getAttribute('data-index')));
            });
            for (const s of sorted) {
                scWrap.appendChild(s);
            }
            layoutRows();
        }, 1.0, performance.now(), 380);
        saveOrder();
        if (chipEl) {
            chipEl.textContent = '저장 ' + JSON.stringify(serializeOrder());
        }
        dragIdx = -1;
    }

pointercancel 도 같은 정리 경로로 들어온다 — 손 입력이 취소돼도 순서는 배열에 이미 반영돼 있어 저장만 하면 그만이다.

08드래그 속도가 고스트의 기울기를 바꾸는 관성 틸트

드래그 속도가 고스트의 기울기를 바꾸는 관성 틸트
전체 코드 새 창에서 열기

08 · 드래그 속도가 고스트의 기울기를 바꾸는 관성 틸트 — 측정 누적면적 28.586% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

GHOST_TILT_MAX_DEGGHOST_SHADOW_BASE_PXlerp
    // 속도→기울기·그림자 계산 — 주입 시연과 실제 손 조작이 같은 함수를 쓴다
    function applyTilt(v, dt) {
        const tilt = clamp(-v * GHOST_TILT_MAX_DEG / 600, -GHOST_TILT_MAX_DEG, GHOST_TILT_MAX_DEG);
        // v→0 이면 lerp 로 되돌아간다 (속도가 없을 때 기울기도 없다)
        const back = Math.abs(v) < 40 ? 0.18 : 1;
        tiltNow = lerp(tiltNow, tilt, back);
        shadowNow = lerp(shadowNow, GHOST_SHADOW_BASE_PX + Math.abs(v) * 0.012, 0.2);
        velLast = v;
        if (gEl) {
            gEl.style.transform = 'rotate(' + f1(tiltNow) + 'deg)';
            gEl.style.boxShadow = '0 ' + f1(shadowNow + 4) + 'px ' + f1(shadowNow * 3) + 'px rgba(0,0,0,.45)';
        }

09화살표 키로 한 칸씩 옮기는 키보드 대체 정렬

포커스된 항목에서 위아래 화살표 입력마다 인접 항목과 자리를 교환해 FLIP 으로 보여 주고, 바뀐 순서를 문장으로 알린다.

화살표 키로 한 칸씩 옮기는 키보드 대체 정렬
전체 코드 새 창에서 열기

09 · 화살표 키로 한 칸씩 옮기는 키보드 대체 정렬 — 측정 누적면적 3.505% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기

role="listbox"aria-liveKEY_STEP_SLOTS

교환 대상은 한 줄의 clamp 다 — 현재 위치에 방향 × KEY_STEP_SLOTS 1 을 더해 0~4 안에 가둔다.

    function swap(dir, t) {
        const cur = order.indexOf(focusIdx);
        const to = clamp(cur + dir * KEY_STEP_SLOTS, 0, 4);
        if (to === cur) {
            return;
        }
        keyCount += 1;
        movedN = flipCommit(scWrap, function applyKey() {
            order.splice(cur, 1);
            order.splice(to, 0, focusIdx);
            const sorted = rows.slice().sort(function (a, b) {
                return order.indexOf(Number(a.getAttribute('data-index'))) - order.indexOf(Number(b.getAttribute('data-index')));
            });
            const lb = scWrap.querySelector('.lbwrap');
            if (lb) {
                for (const s of sorted) {
                    lb.appendChild(s);
                }
            }
            layoutRows();
            announce();
        }, 1.0, t, 320);

포커스 유지와 안내 문장이 이 판의 접근성 겹이다.

        // 포커스 유지 — 항목이 움직여도 포커스는 그 항목에 남는다 (스크롤 강제 금지)
        const fe = rows[focusIdx];
        if (fe && document.activeElement === fe) {
            fe.focus({ preventScroll: true });
        }
    function announce() {
        // 화면 낭독기 문장 — 문구·모드가 바뀔 때만 갱신한다 (매 프레임 숫자 금지)
        const seq = rows.slice().sort(function (a, b) {
            return order.indexOf(Number(a.getAttribute('data-index'))) - order.indexOf(Number(b.getAttribute('data-index')));
        }).map(function (r) { return r.querySelector('.card__tx').textContent; }).join(', ');
        doneP.textContent = '새 순서: ' + seq;
    }

이런 화면에 붙인다

드래그 정렬이 실제로 사는 자리는 대부분 세 군데로 모인다. 재생목록·즐겨찾기·위시리스트처럼 사용자가 자기 순서를 갖는 짧은 목록(01·02·07), 칸반·스프린트 보드처럼 상태 컬럼 사이를 오가는 업무 화면(04), 앱 런처·갤러리·위젯 편집처럼 격자에 놓인 편성 화면(03·08)이다. 길이가 화면을 넘는 순간 05 를 얹고 행 안에 다른 조작이 있으면 06 으로 좁히고 키보드 접근이 요구되면 09 를 붙인다.

짧은 목록에 곡선 오토스크롤까지 얹는 과잉은 피한다. 항목이 한 화면 안에 다 보이면 05 는 죽은 코드고, 이 글의 아홉 장면도 각자 얹을 때가 있는 계산이지 전부 얹어야 하는 체크리스트가 아니다. 반대로 실무에서 가장 자주 빠뜨리는 것은 09 의 키보드 경로와 07 의 저장인데, 둘 다 마지막에 붙이려면 목록 구조를 다시 건드려야 하므로 배열을 data 중심으로 잡는 시점, 즉 01 을 만드는 순간부터 설계에 들어 있어야 한다.

어디서 깨지는가 — 첫측정 타이밍·리플로우·pointercancel·선택 충돌·touch-action·중간점 진동

이 편을 만들며 직접 부딪힌 것 여섯이다. 각각 깨지는 조건과 수리를 함께 적는다.

첫째, FLIP 첫측정 타이밍이다. First 를 잰 뒤 DOM 을 고치고 Last 를 재는데, 그 사이에 강제 리플로우(오프스크린 측정·display 토글)를 넣으면 First 값이 어긋나 카드가 엉뚱한 방향에서 날아온다. 수리는 같은 프레임 안에서 연속 측정하는 것과, 무대가 scale(k) 로 축소되어 있으므로 rect 차이를 k = rootEl.clientWidth / 480 로 나눠 무대 좌표로 환산하는 것이다 — 이 보정이 없으면 축소된 무대에서 이동 거리가 k 배 과대 측정된다.

둘째, 드래그 중 리플로우다. 고스트를 실제 카드의 이동으로 대신하면 매 pointermove 마다 레이아웃이 다시 계산된다. 수리는 고스트를 position: absolute 복제로 띄우고 원본은 opacity 만 바꾸는 구조다 — makeGhost 가 그 구조 자체고, 원본은 계속 문서 흐름에 있으므로 나머지 카드의 위치는 배열이 바뀔 때만 움직인다.

셋째, pointercancel 미해제다. 손가락이 화면 밖으로 나가거나 시스템이 제스처를 뺏으면 pointerup 이 안 온다. pointercancel 을 놓기와 같은 정리 경로에 묶지 않으면 고스트가 화면에 남는다 — 이 편 아홉 장면은 전부 pointercancel → release 로 묶여 있고, 05 처럼 rAF 스크롤 루프가 살아 있는 판은 루프까지 끊는다. 미해제가 남는 건 고스트뿐이 아니다 — 07 의 저장도 놓기 경로에서 일어나므로 같은 링크로 자연히 해결된다.

넷째, 텍스트 선택·이미지 드래그 충돌이다. 드래그 시작을 막지 않으면 글자 선택이 드래그를 이긴다 — 카드를 끌면 카드가 아니라 글자가 파랗게 선택된다. 수리는 카드에 user-select: none 을 주는 것인데, 06 의 설계(행 본문은 드래그 불가)와 합치면 선택이 필요한 영역은 살리고 드래그가 필요한 영역만 잠긴다.

다섯째, 터치 스크롤 충돌이다. 카드에 touch-action: none 을 줘야 손가락 드래그가 페이지 스크롤에 뺏기지 않는데, 스크롤이 살아 있어야 하는 목록 컨테이너까지 none 으로 주면 이번엔 목록이 안 굴러간다. 수리는 영역별 분리다 — 카드는 none, 05 의 목록 컨테이너는 pan-y 로 세로 스크롤을 살려 둔다. 06 시연에서 거부되는 행 본문 누름이 이 분리가 없을 때 손가락에게 무슨 일이 벌어지는지 보여 주는 셈이다.

여섯째, 반올림이 만드는 중간점 진동이다(02 시연). 슬롯 판정을 Math.round((cy-7)/(ROW_H+GAP)) 만으로 하면 중심점이 슬롯 중간점 근처에서 왔다 갔다 할 때마다 배열이 바뀌어 항목이 떨린다. 수리는 임계 판정 한 번 더다 — 원 슬롯과의 거리가 SWAP_THRESHOLD_RATIO 를 넘어야 바뀐다는 히스테리시스. 이 한 줄이 없으면 같은 코드가 데스크톱 마우스에서는 멀쩡하고 터치에서는 떨리는 이유가 된다.

값을 바꿔 본 차이

세 변형은 각각 상수 하나만 바꾼 전후를 장면에서 직접 볼 수 있다.

이름 바꾼 값 느낌
자리바꿈 임계 반칸 조정 02 SWAP_THRESHOLD_RATIO 0.5 → 0.85 0.5 는 중간점 통과 즉시 스왑이라 가볍게 훑기만 해도 자리가 바뀌는데, 0.85 는 이웃을 거의 다 덮어야 바뀌어 손을 크게 움직여야 한다 — 실수로 스왑되는 일은 줄고, 대신 정밀하게 끌려면 힘이 더 든다
FLIP 이동 재생 배율 조정 01 FLIP_PLAY_SCALE 1.0 → 1.6 역변환 초기 거리가 실측의 1.6배가 되어 밀리는 행이 실제보다 멀리 나갔다 돌아온다 — 1.0 은 측정 거리 그대로 딱 움직이는 담백함, 1.6 은 탄력이 붙어 가벼운 통통거림으로 읽힌다
오토스크롤 속도 곡선 기울기 조정 05 AUTOSCROLL_CURVE_POW 1.2 → 2.4 1.2 는 엣지존 안에서 비교적 고르게 가속해 순하고, 2.4 는 경계 근처까지 느리다가 급가속해 손끝 반응이 날카로워진다 — 같은 최대 속도인데 지수만으로 손맛이 갈린다

각 장면의 소스와 react 판을 한데 묶은 zip 을 아래 상자에서 받아 열 수 있고, 열 때 쓰는 암호는 g3zfh9gy 이다. 임계 판정·FLIP 역변환·곡선 가속이 라이브러리 없이 각각 몇 줄인지 코드에서 직접 확인할 수 있다.

포인터 없이 쓰는 접근성 경로 — 09 키보드 재정렬과 prefers-reduced-motion

09 장면이 그대로 실전용 뼈대다. role="listbox" 안에 항목을 option 으로 두고 roving tabindex — 포커스는 항상 항목 하나에만(나머지는 tabindex -1) 있으며 순서가 바뀌면 포커스도 그 항목을 따라간다. fe.focus({ preventScroll: true }) 가 그 이동인데 스크롤 강제를 끄지 않으면 키 한 번에 화면이 점프한다. 상태 줄은 aria-live 를 꺼 두고 완성 문장만 role="status" aria-live="polite" 로 바꿔 읽는다 — 매 프레임 숫자를 읽으면 스크린리더가 혼잡해지기 때문이다.

prefers-reduced-motion 이 켜지면 FLIP 재생을 건너뛰고 확정 상태로 바꾼다 — flipCommit 의 reduced 분기가 transform 을 비우므로 놓기 전과 놓은 뒤의 두 상태만 보인다. 키 입력·드롭은 재생 없이도 target 갱신 직후 화면에 반영되므로 동작이 죽지 않는다.

caniuse 에서 2026-11-16 에 직접 확인한 값이다. Pointer Events API 는 Chrome 55+ · Firefox 59+ · Safari 13+ 로 전역 97.49% — 이 글 아홉 장면의 기반이다. HTML5 draggable 은 전역 97.57% 로 수치는 더 높지만 모바일 브라우저가 네이티브 D&D 이벤트를 보내지 않는 갭이 있어, 터치까지 한 경로로 겸하려면 Pointer Events 가 정답이다. touch-action 은 Chrome 36+ · Firefox 52+ · Safari 13+, prefers-reduced-motion 은 Chrome 74+ · Firefox 63+ · Safari 10.1+ 다. JS 가 꺼진 환경에서는 목록이 정적 리스트로 남는다 — 드래그 정렬은 점진적 향상이고 저장이 실패해도 목록 자체는 동작한다.

이 코드를 그대로 가져갈 때의 최소 reduce 가드는 아래와 같다.

@media (prefers-reduced-motion: reduce) {
  .card { transition: none; }
}

관련 글은 드래그 재정렬 UI 패턴 · 드래그 앤 드롭 물리 패턴 · 리스트 확장 체크리스트 UI 에 이어져 있다. 출처: MDN Pointer events · MDN transform · MDN touch-action · MDN getBoundingClientRect

드래그 정렬 리스트 FAQ — 모바일·순서 저장·라이브러리·성능

드래그 정렬이 모바일 터치에서도 되나요

됩니다. 아홉 장면은 전부 Pointer Events 기반이라 마우스·터치·펜을 같은 핸들러로 받습니다. 다만 카드에 touch-action: none 을 주지 않으면 손가락 드래그가 페이지 스크롤에 뺏기고, 목록이 길어 스크롤이 필요하면 컨테이너는 pan-y 로 분리해야 합니다. caniuse 실측 2026-11-16 기준 iOS Safari 13.2+ 에서 전체 지원입니다.

바뀐 순서는 저장되나요

07 장면이 저장 한 겹 전부입니다. 드래그가 끝날 때마다 data-index 배열을 직렬화해 localStorage 에 넣고 로드에서 복원합니다. 사파리 프라이빗 모드의 예외를 막는 try/catch 와 항목 수가 바뀐 뒤의 짝 확인까지가 실전 코드고, 서버에 올리려면 같은 배열을 fetch 로 보내기만 하면 됩니다.

sortable js library 없이 정말 만들 수 있나요

만들 수 있습니다 — 이 페이지의 아홉 장면이 전부 라이브러리 없이 돌아갑니다. 핵심은 중심점 통과 판정 한 곳(02)과 FLIP 넉 단계(01)뿐이고 나머지는 그 두 계산의 변형입니다. drag and drop list codepen 을 찾아 헤매는 대신 이 페이지에서 각 장면의 소스를 그대로 복사해 붙여 쓰면 됩니다. 페이지를 떠나 열어 보는 수고도 없이요.

압축 비밀번호를 입력하세요

비밀번호는 이 글 본문 안에 있습니다. 읽다 보면 나옵니다.