Documentação/API

makeSortableList

Torna um contêiner uma lista ordenável — um rascunho que se reordena enquanto você arrasta, gravado de volta no drop.

Editar esta página

Esta página foi traduzida por IA e pode conter imprecisões. Ler o original em inglês

function makeSortableList<T>(  target: MaybeElementRef,  options: SortableListOptions<T>,): SortableListReturn<T>;

Torna um contêiner uma lista ordenável. Renderize os items retornados (a ordem do rascunho), não o seu array: o drop é escrito de volta em options.items, depois de onDrop, a menos que event.preventDefault() deixe event.result com você.

const list = useTemplateRef<HTMLElement>('list');
const { items } = makeSortableList(list, { items: tasks, group: 'board' });

As linhas dela chamam makeSortableItem. Veja Listas ordenáveis e Listas que compartilham itens.

Live

Carregando a demo…

<script setup lang="ts">
import { ref } from 'vue';
import { DnDProvider } from '@vue-dnd-kit/core';
import Segmented from './Segmented.vue';
import Tiles from './Tiles.vue';

const strategy = ref<'vertical' | 'horizontal' | 'grid'>('grid');
const placeholder = ref<'item' | 'indicator'>('item');
const behavior = ref<'sort' | 'swap'>('sort');
</script>

<template>
  <DnDProvider>
    <div class="demo">
      <div class="switches">
        <Segmented v-model="strategy" name="strategy" :options="['vertical', 'horizontal', 'grid']" />
        <Segmented v-model="placeholder" name="placeholder" :options="['item', 'indicator']" />
        <Segmented v-model="behavior" name="behavior" :options="['sort', 'swap']" />
      </div>
      <code class="call">makeSortableList(el, { strategy: '{{ strategy }}', placeholder: '{{ placeholder }}', behavior: '{{ behavior }}' })</code>
      <Tiles :strategy="strategy" :placeholder="placeholder" :behavior="behavior" />
    </div>
  </DnDProvider>
</template>

<style scoped>
.demo {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 18px;
  max-width: 100%;
}

.switches {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: 16px;
}

.call {
  max-width: 100%;
  padding: 6px 10px;
  overflow-x: auto;
  border-radius: 8px;
  background: color-mix(in srgb, currentColor 6%, transparent);
  font: 11px/1.4 ui-monospace, Menlo, Consolas, monospace;
  white-space: nowrap;
  color: #42b883;
}
</style>

Opções

Opções de makeSortableList. Um componente pode criar várias listas (e árvores): cada item renderizado nele entra na mais interna cujo elemento o contém.

As opções aceitam um valor, um ref ou um getter (overlay, overOverlay, dropAnimation, overDropAnimation, animation: um valor ou um ref) e são lidas quando a lista precisa delas, então uma mudança vale, no máximo, a partir do próximo arraste. Exceções: id e group são lidos uma única vez, quando a lista é criada; items é o próprio model; funções (getKey, filter, clone, createItem, os callbacks) são passadas como estão.

SortableItems<T>

Fonte da verdade. Um ref gravável recebe o novo array no drop, logo depois do onDrop. Uma fonte somente leitura (um getter, um ref readonly, um computed) não pode recebê-lo: chame event.preventDefault() e aplique event.result você mesmo. Os builds de desenvolvimento avisam quando um drop fica a cargo da biblioteca nesse caso, e então nada muda.

(item: T) => Key

Padrão: item.id, ou o próprio item no caso de primitivos. Também define as keys de makeSortableItem({ item }).

(item: T) => boolean

Mostra só os itens para os quais retorna true (uma busca, uma tag): items (o retornado) contém esses itens, e um arraste ordena entre eles. Os outros mantêm os seus lugares na origem: um drop escreve o array inteiro, com cada item oculto ainda depois do visível que ele seguia (depois do mais próximo que ficou, quando aquele se moveu). Reativo: o que ele lê (um ref de busca) vale na hora. e.to.index e activeIndex contam os itens mostrados.

Key

Padrão: useId(), estável entre a renderização no servidor e no cliente. Lido uma única vez.

stringvalor · ref · getter

Como as pessoas chamam a lista: os textos para leitores de tela dizem isso em vez do id dela (position 2 of 5 in Garden).

unknownvalor · ref · getter

Qualquer coisa a dizer sobre a lista como alvo de drop: os eventos a carregam como over.data enquanto um arraste está sobre ela.

ActivationOptionsvalor · ref · getter

Como um clique nos itens desta lista começa um arraste, em vez da activation do provider (a do próprio item prevalece). Lido quando um clique começa.

Componentvalor · ref

Componente de overlay para os itens desta lista (o overlay do próprio item prevalece). Ele recebe OverlayProps e é mantido durante todo o arraste, inclusive sobre outras listas, a menos que o alvo sob o arraste tenha um overlay próprio (overOverlay). Um ref trocado durante o arraste o troca na hora.

Componentvalor · ref

O que o overlay mostra enquanto um arraste que esta lista aceita está sobre ela, venha de qual lista vier: um componente que recebe OverlayProps e o overlay do próprio arraste como slot padrão (veja DroppableOptions.overOverlay). Lido ao vivo.

DropAnimationvalor · ref

Como o overlay pousa quando um arraste dos itens desta lista termina, em vez do dropAnimation do provider (o do próprio item prevalece; o de um alvo de drop prevalece sobre os dois). Lido no drop.

DropAnimationvalor · ref

Como o overlay pousa quando é solto nesta lista, venha de qual lista vier: prevalece sobre o dropAnimation do item arrastado e do provider. Lido no drop.

Modifier[]valor · ref · getter

Modificadores para os arrastes dos itens desta lista, aplicados depois dos modifiers do provider (os modifiers do próprio item prevalecem): por exemplo, [restrictToVerticalAxis] para manter os itens de uma lista vertical no seu eixo. Lido quando o arraste começa.

'x' | 'y'valor · ref · getter

Trava em um eixo os arrastes dos itens desta lista: 'y' para uma lista vertical, 'x' para uma horizontal (o axis do próprio item prevalece). A trava vem depois dos modificadores, então se mantém não importa o que eles façam. Lido quando o arraste começa.

string | SortableGroupOptions<T>

Listas com o mesmo nome de grupo trocam itens. Padrão: um grupo à parte. Lido uma única vez.

AcceptModevalor · ref · getter

Multi-drag de itens de vários tipos: 'all' (padrão) ou 'some' precisam ser aceitos (group.put).

SortableStrategyvalor · ref · getter

Padrão 'vertical'.

SortableBehaviorvalor · ref · getter

'swap': o item arrastado troca de lugar com o que está sob o ponteiro, ao vivo; voltar para cima dele ou sair das listas desfaz a troca. Listas de um mesmo grupo que ambas trocam passam itens entre si: o item sob o ponteiro vai para o lugar do arrastado, então precisa poder sair da sua lista (group.pull: true) e entrar na do item arrastado (group.put). O multi-drag ordena em vez disso. Padrão 'sort'.

SortablePlaceholdervalor · ref · getter

'indicator': a lista não se move, indicator diz para onde vai o drop. Padrão 'item'.

MultipleModevalor · ref · getter

Modo de multi-drag dos arrastes que começam nesta lista. Padrão 'group'. Lido quando o arraste começa.

booleanvalor · ref · getter

false: os itens não podem ser reordenados dentro desta lista (paletas).

(item: T) => T

Cria cópias (pull: 'clone', tecla modificadora de cópia). Obrigatório para copiar.

(active: Active) => T | T[]

Aceita draggables simples de fora: cria o item a inserir. Pelo teclado, uma seta em direção à lista leva o draggable para dentro dela (na altura dele, como nos movimentos entre listas), e o item criado então se move de posição em posição como qualquer outro.

Um arraste de fora da página (external) faz a pergunta duas vezes: durante o arraste, pelo item que mostra para onde ele vai (só active.external.fileTypes e types são conhecidos nesse momento), e no drop, com os dados dele (active.external.ready), pelo que é inserido. Um array de itens insere todos onde estava a posição: um por arquivo.

ExternalAcceptvalor · ref · getter

Aceita arrastes de fora da página: arquivos, links, texto (veja ExternalAccept). A lista abre espaço para eles como para um draggable simples, com createItem, que ela exige. Itens do grupo dela arrastados de outra janela do app (native) não precisam de nenhuma das duas opções: entram como eles mesmos. Um valor, um ref ou um getter, lido ao vivo.

DropOutsidevalor · ref · getter

Um drop fora de todos os alvos: manter os itens onde está o placeholder, cancelar ou removê-los. Padrão 'placeholder' ('cancel' com placeholder: 'indicator'). Lido no drop.

LayoutAnimationvalor · ref

Animação FLIP desta lista; padrão: a animation do provider. Um valor ou um ref (uma função é uma animação personalizada).

AutoAnimationvalor · ref · getter

Anima as mudanças em items que nenhum arraste fez: itens adicionados, removidos, movidos e filtrados (veja AutoAnimation). Padrão: o animateChanges do provider, desligado a menos que definido ali. Lido quando items muda.

booleanvalor · ref · getter

O tamanho da própria lista acompanha os itens dela: quando um arraste traz um item ou leva um embora (e no drop, e nas mudanças que animateChanges mostra), ela cresce ou encolhe até o novo tamanho com a duração e o easing de animation em vez de pular, e o que está em volta se move junto. Padrão true; false a deixa pular. Lido a cada mudança.

boolean | AutoScrollOptionsvalor · ref · getter

Sobrescreve o autoScroll do provider para o contêiner de rolagem desta lista. Lido quando o arraste começa.

MaybeElementRef

O elemento que recebe os drops pela lista; por padrão, o próprio elemento da lista. Por exemplo, a coluna inteira ao redor de uma lista curta de cards, para que um card solto abaixo do último ainda pouse na lista (no final dela). Os itens ficam no elemento da lista.

booleanvalor · ref · getter

true: os itens dela não podem ser arrastados, e ela não aceita itens.

( event: SortableDropEvent<T>, ) => MaybePromise<BeforeDropResult>

Consultado antes de um drop nesta lista, e antes de dropOutside: 'remove' tirar os itens dela: false o rejeita (os itens voltam ao lugar), algumas keys aceitam só esses itens. Pode ser assíncrono: o overlay espera onde foi solto. Um erro também rejeita o drop. Veja SortableDropEvent para result e preventDefault.

(event: SortableDropEvent<T>) => void

Chamado assim que um drop nesta lista é aceito, antes de ser gravado: items ainda tem a ordem antiga, event.result, a nova. Síncrono: a gravação vem assim que ele retorna, a menos que tenha chamado event.preventDefault(). Também é chamado na lista de onde os itens vieram quando eles são removidos (to.index é -1).

Retorno

O que makeSortableList retorna.

Key

O id da lista: a opção id, ou o que foi gerado para ela.

ComputedRef<T[]>

Ordem do rascunho: renderize isto, não o array de origem.

ComputedRef<boolean>

Um arraste está sobre a lista.

ComputedRef<boolean>

Algo está sendo arrastado e esta lista o aceita.

ComputedRef<SortableIndicator | null>

Modo indicador: para onde vai o drop nesta lista; null quando não é aqui.

ComputedRef<Key | null>

A linha que um virtualizador precisa manter montada: a posição enquanto ela está nesta lista (uma cópia, um item criado), senão o item arrastado; null sem arraste.

ComputedRef<number>

Índice do item ativo no rascunho desta lista, -1 quando ele não está aqui.

ComputedRef<Size | null>

Tamanho do item arrastado no início do arraste: por exemplo, para o tamanho de uma linha virtual que ele ocupa.

() => void

Anima mudanças de layout que a biblioteca não causou (por exemplo, uma nova medição de um virtualizador).

Grupos

O grupo de uma lista: as listas que trocam itens, e se os itens podem sair desta e entrar nela.

string

Listas e árvores com o mesmo nome trocam itens.

boolean | 'clone'

Se os itens podem sair desta lista: mover, copiar ('clone', uma paleta) ou de jeito nenhum.

boolean | string | string[] | ((context: SortablePutContext<T>) => boolean)

Se os itens podem entrar nesta lista: true (padrão), false, um tipo ou tipos que os itens precisam ter (como o accept de um alvo de drop: com acceptMode, todos ou alguns), ou uma função do arraste.

Com o que um group.put em forma de função é consultado: os itens que entrariam na lista.

Key[]

Keys dos itens.

T[]

Os itens (para um draggable simples, o item que createItem criou).

string[]

Os tipos dos itens, juntos.

Key | null

Lista de origem, null para draggables externos.

Key

Id da lista consultada.

O evento de drop

O que onBeforeDrop e onDrop recebem.

Um drop em uma lista ou árvore ordenável. Os hooks dele rodam em ordem: onBeforeDrop decide, onDrop é avisado, depois a ação padrão grava result nos items de cada lista que ele cita, e o overlay pousa. preventDefault() em qualquer um dos hooks pula essa gravação, para que você aplique result você mesmo.

Key[]

Keys dos itens arrastados.

T[]

Os itens que pousam: os arrastados, as cópias deles (mode: 'copy'), ou o item que createItem criou ('insert').

Key[]

Keys que se concretizam: todas, a menos que a lista ou onBeforeDrop aceite só algumas.

Key[]

Keys que voltam para onde estavam.

{ list: Key | null; index: number }

Onde o arraste começou: a lista e o índice do item ativo. list é null para um draggable simples de fora.

{ list: Key; index: number }

index é -1 quando nada pousou: os itens saíram das suas listas (e.source.remove(), dropOutside: 'remove').

boolean

O drop fica na lista onde o arraste começou.

DragMode

O que o drop faz (veja DragMode).

{ key: Key; item: T; from: { list: Key; index: number }; to: { list: Key; index: number } }

mode: 'swap': o item com o qual o arrastado foi trocado. Ele se moveu no sentido inverso, from o lugar que o item arrastado ocupou (to acima) to aquele onde o item arrastado começou (from acima); entre listas, para a lista do item arrastado.

ReadonlyMap<Key, T[]>

Os novos itens de cada lista que o drop altera, por id de lista: exatamente o que a gravação padrão coloca nos items delas, como novos arrays. Movimentos, cópias, itens criados, uma aceitação parcial, os dois lados de uma troca e itens removidos (e.source.remove() em um alvo dentro de um item, uma zona de lixeira, dropOutside: 'remove') estão todos ali; uma lista que o drop deixa como está não está. A entrada de uma árvore é um novo array de raízes: os nós nos caminhos alterados são cópias (withChildren), as subárvores intactas são compartilhadas, os seus nós nunca são mutados. No onBeforeDrop, é o drop como está antes de o hook responder (retornar algumas keys o altera); o onDrop recebe o final.

() => void

Pula a gravação padrão, em todas as listas de result (gravar só em algumas perderia ou duplicaria itens). Aplique result você mesmo no onDrop, ou antes de um onBeforeDrop assíncrono ser resolvido, e o overlay pousa na nova ordem. Se não for aplicado em lugar nenhum, as listas ficam como estavam e o overlay volta ao lugar (cópias e itens criados, que ainda não têm lugar, desaparecem aos poucos).

boolean

preventDefault() foi chamado, no onBeforeDrop ou no onDrop.

ExternalData

Um arraste de fora da página (external): o que ele carregava, com os dados dele (ele foi solto).

Indicador

O que indicator contém no modo placeholder: 'indicator'.

Para onde vai o drop com placeholder: 'indicator': a lista não se mexe, você desenha a linha.

Key

Id da lista (ou árvore) para onde vai o drop.

number

Posição de inserção na lista como renderizada.

Key | null

Item ao qual o indicador está preso; null em uma lista vazia.

'before' | 'after' | 'inside' | 'swap'

Lado de key em que a linha fica. 'inside' (árvores): o ponteiro está sobre o meio de uma linha que aceita os nós arrastados, e o drop vai para dentro dela como o primeiro filho. 'swap' (behavior: 'swap'): key é o item com o qual o drop troca de lugar; marque o próprio item.

number

Árvores: profundidade que os nós soltos recebem (as raízes são 0), por exemplo, para indentar a linha.

Key | null

Árvores: pai que os nós soltos recebem, null no nível das raízes.

Valores

Uma fonte de itens ordenáveis. Um ref gravável: a biblioteca grava cada drop nele. Um somente leitura (um getter, um ref readonly, um computed: uma store imutável, estado do servidor, uma store alterada só por actions): você aplica cada drop a partir de event.result, depois de event.preventDefault() (veja SortableDropEvent).

type SortableItems = Ref<T[]> | Readonly<Ref<readonly T[]>> | (() => readonly T[])

Como uma lista dispõe os itens: uma coluna ('vertical'), uma linha ('horizontal') ou uma grade que quebra linha ('grid').

type SortableStrategy = 'vertical' | 'horizontal' | 'grid'

O que passar sobre um item faz: 'sort' abre espaço (os itens no meio se deslocam), 'swap' troca os dois itens de lugar.

type SortableBehavior = 'sort' | 'swap'

Como um arraste mostra para onde vai: 'item', a posição do item arrastado se move pela lista; 'indicator', a lista fica como está e indicator diz para onde vai o drop (você desenha a linha).

type SortablePlaceholder = 'item' | 'indicator'

O que os outros itens selecionados fazem em um multi-drag:

  • 'group': eles saem dos seus lugares e viajam com o item ativo como placeholders contíguos, então, ao passar por cima, a lista já mostra o resultado do drop;
  • 'gaps': eles ficam no lugar até o drop;
  • 'stack': eles se recolhem para dentro do overlay.

O overlay padrão mostra os itens arrastados em uma coluna na direção da lista ('group', 'gaps'; uma linha em listas horizontais, uma pilha atrás do item ativo em grades), ou o item ativo com um contador ('stack').

type MultipleMode = 'group' | 'gaps' | 'stack'

O que um drop fora de todos os alvos faz: 'placeholder' mantém os itens onde está a posição deles, 'cancel' os manda de volta, 'remove' os tira da lista deles.

type DropOutside = 'placeholder' | 'cancel' | 'remove'