@snksergio/design-system 0.58.0 → 0.60.0

package/dist-lib/src/components/ui/Gantt/hooks/layout.d.ts

@@ -0,0 +1,232 @@
+import { Locale } from 'date-fns';
+import { GanttBar, GanttGranularity, GanttRow } from '../gantt.types';
+/**
+ * Núcleo geométrico do `Gantt` — **puro**: sem React, sem DOM, sem estilo.
+ *
+ * É o que torna as bordas testáveis sem montar componente: virada de mês,
+ * barra que cruza a janela, lane packing com sobreposição parcial, `summary`
+ * derivado de filhos colapsados.
+ *
+ * ## A unidade é o DIA, e isso é decisão
+ *
+ * Todo cálculo interno converte data → **dias desde `windowStart`** e só depois
+ * multiplica por `pxPerDay`. A alternativa (converter direto pra pixel em cada
+ * lugar) espalha o arredondamento e faz duas barras com a mesma data cair em
+ * pixels diferentes dependendo de quem calculou.
+ *
+ * ⚠️ Usa `differenceInCalendarDays`, **não** subtração de timestamp: um
+ * intervalo que cruza mudança de horário de verão tem 23 ou 25 horas, e
+ * `(b - a) / 86400000` devolve 0,96 dia. O cálculo por calendário devolve 1.
+ */
+export type GanttTick = {
+    /** Início do tick. */
+    date: Date;
+    /** Largura em dias — varia: mês tem 28–31, trimestre 90–92. */
+    spanDays: number;
+    label: string;
+    /** Fim de semana, pra sombrear a coluna. Só em `granularity: "day"`. */
+    isWeekend: boolean;
+};
+export type GanttAxis = {
+    /** Linha de cima — agrupa (mês sobre dias, ano sobre meses). */
+    groups: GanttTick[];
+    /** Linha de baixo — a unidade da grade. */
+    units: GanttTick[];
+    totalDays: number;
+};
+/**
+ * Eixo em DOIS níveis, porque uma linha só não situa.
+ *
+ * Todas as 13 referências fazem isso: "March | April | May" em cima e
+ * "01.03–07.03 | 08.03–14.03" embaixo. Sem o nível de cima, uma coluna "12" não
+ * diz de que mês — e o usuário precisa contar colunas pra descobrir.
+ */
+export declare function buildTimeAxis(windowStart: Date, windowEnd: Date, granularity: GanttGranularity, locale?: Locale, weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6): GanttAxis;
+/** Dias desde o início da janela. Fracionário: a hora do dia conta. */
+export declare function dateToDayOffset(date: Date, windowStart: Date): number;
+export declare function dateToX(date: Date, windowStart: Date, pxPerDay: number): number;
+export declare function xToDate(x: number, windowStart: Date, pxPerDay: number): Date;
+/**
+ * Arredonda pro início do período — o snap do arraste.
+ *
+ * Sem snap, arrastar 3px muda a data em 4 horas e a barra nunca alinha com a
+ * grade. Com snap por granularidade, ela cai sempre num limite visível.
+ */
+export declare function snapDate(date: Date, granularity: GanttGranularity, weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6): Date;
+export type GanttClippedBar = {
+    bar: GanttBar;
+    /** Início efetivo desenhado — pode ser a borda da janela. */
+    start: Date;
+    end: Date;
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+};
+/**
+ * Recorta a barra na janela visível.
+ *
+ * Devolve `null` quando a barra está **inteiramente fora** — e é o que evita
+ * desenhar centenas de nós com `left` negativo fora da viewport.
+ *
+ * ⚠️ A comparação é por DIA, não por instante: uma barra que termina às 08:00 do
+ * `windowStart` ainda toca a janela e deve aparecer. Comparar timestamps a
+ * descartaria.
+ */
+export declare function clipToWindow(bar: GanttBar, windowStart: Date, windowEnd: Date): GanttClippedBar | null;
+/**
+ * Distribui barras em lanes dentro da MESMA linha.
+ *
+ * - `stack`: uma lane por barra, na ordem recebida. Todas visíveis — é o
+ *   "arco-íris" do portfólio, onde o ponto é justamente ver as 5 frentes.
+ * - `compact`: barras que não se sobrepõem dividem lane. Linha mais baixa, e o
+ *   preço é que duas frentes podem cair na mesma faixa horizontal.
+ *
+ * ⚠️ Sobreposição é `<` e não `<=`: uma barra que termina no dia 5 e outra que
+ * começa no dia 5 **não** se sobrepõem — são consecutivas. Usar `<=` empurraria
+ * toda cadeia sequencial pra lanes separadas, que é o oposto de "compact".
+ */
+export declare function packLanes(bars: GanttClippedBar[], mode?: "stack" | "compact"): GanttClippedBar[][];
+export type GanttFlatRow = {
+    row: GanttRow;
+    depth: number;
+    /** Tem filhos — é o que decide se o chevron aparece. */
+    hasChildren: boolean;
+    collapsed: boolean;
+    /**
+     * É o ÚLTIMO filho do seu pai — define se a vertical do conector para no meio
+     * da linha (formando o "└") ou atravessa até a base (formando o "├").
+     */
+    isLast: boolean;
+    /**
+     * Por nível ancestral (índice = `depth` do ancestral): aquele ancestral ainda
+     * tem irmão depois dele? Controla se a guia vertical continua descendo naquela
+     * coluna de recuo.
+     *
+     * ⚠️ **A coluna `i` hospeda o cotovelo de nós em `depth i+1`**, então quem
+     * decide a continuação vertical dela é `ancestorHasNext[i + 1]`, NÃO `[i]`.
+     * Esse off-by-one é a **L-045**, e ela nasceu deste mesmo conector no `List`:
+     * com `[i]` a guia sumia no último root (`ancestorHasNext[0]` é `false`) e nos
+     * demais o root tinha irmão, o que mascarava o bug em tudo menos na borda.
+     *
+     * A forma deste campo é copiada do `flattenTree` do `List` de propósito — é a
+     * implementação que já pagou o preço de acertar.
+     */
+    ancestorHasNext: boolean[];
+};
+/**
+ * Achata a árvore na ordem de exibição, respeitando collapse.
+ *
+ * Filho de linha colapsada não entra — nem os netos. É por isso que a recursão
+ * para no `collapsed` em vez de filtrar depois: filtrar deixaria neto órfão
+ * visível quando o pai colapsa e o avô não.
+ *
+ * ## Dado sujo do consumidor nunca vira tarefa invisível
+ *
+ * Duas formas de `parent` quebrado, e as DUAS terminam com a linha na tela:
+ *
+ * 1. **`parent` aponta pra id inexistente** → tratada como raiz.
+ * 2. **Ciclo em `parent`** (A pai de B, B pai de A) → o grupo inteiro é
+ *    promovido a raiz, no fim da lista.
+ *
+ * ⚠️ O caso 2 **não funcionava** até este teste existir. A guarda `visitados`
+ * impedia o estouro de pilha, mas a varredura partia de `porPai.get(null)` — e
+ * num ciclo puro NENHUMA linha tem pai nulo, então o balde raiz vem vazio e a
+ * função devolvia `[]`. O Gantt renderizava **em branco**, sem erro, com todas
+ * as tarefas no `rows`.
+ *
+ * Era a L-060 na prática: este bloco de comentário já prometia "não deve virar
+ * tarefa invisível", e quem leu (eu, duas rodadas atrás) parou de investigar.
+ * Comentário que afirma garantia tem que ter a garantia verificada.
+ */
+export declare function flattenRows(rows: GanttRow[], collapsedIds: ReadonlySet<string>): GanttFlatRow[];
+/**
+ * Intervalo de um `summary`, derivado dos descendentes.
+ *
+ * Devolve `null` quando não há descendente com barra — e aí o `summary` não
+ * desenha nada, em vez de desenhar uma barra de duração zero em 1970.
+ *
+ * ⚠️ Percorre TODA a descendência, não só os filhos diretos: um `summary` de
+ * fase cujos filhos são outros `summary` teria intervalo vazio se olhasse um
+ * nível só.
+ */
+export declare function deriveSummaryRange(rowId: string, rows: GanttRow[]): {
+    start: Date;
+    end: Date;
+} | null;
+/**
+ * Janela a partir dos dados, pro caso em que o consumidor não passa uma.
+ *
+ * A folga de 1 unidade em cada ponta não é estética: sem ela, a primeira e a
+ * última barra encostam na borda e ficam indistinguíveis de barras que
+ * atravessam a janela (que é o que `continuesBefore/After` sinaliza).
+ */
+export declare function deriveWindow(rows: GanttRow[], granularity?: GanttGranularity): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Altura de cada linha visível — **a fonte ÚNICA, consumida pelos dois painéis**.
+ *
+ * ⚠️ Isto existe porque a primeira versão calculava a altura em DOIS lugares: o
+ * canvas somava lanes (`n * LANE + 8`) e a grade usava a constante fixa. Numa
+ * linha-contêiner com 3 barras, o canvas dava 98px e a grade 44 — e as duas
+ * metades da MESMA linha ficavam com alturas diferentes, com o nome desalinhado
+ * das barras a partir dali pra baixo.
+ *
+ * É exatamente a L-038: default resolvido em dois render-sites que divergem. A
+ * correção é resolver na fonte, não em cada lugar.
+ */
+export declare function rowHeights(rows: readonly GanttFlatRow[], baseHeight: number, laneHeight: number): number[];
+/** `top` acumulado de cada linha, a partir das alturas. */
+export declare function rowOffsets(heights: readonly number[]): number[];
+/**
+ * Matriz do mês — 6 linhas × 7 colunas, SEMPRE.
+ *
+ * ⚠️ **Duplicado de propósito do `Scheduler`.** A spec (§5) registra a decisão:
+ * o `Gantt` é dono das suas visões porque delegar criaria acoplamento por
+ * herança de propósito — necessidade nova do Gantt viraria mudança numa API
+ * publicada que serve outros consumidores.
+ *
+ * O que a duplicação NÃO pode causar é divergência silenciosa de layout, e é
+ * por isso que esta função tem teste próprio sobre as mesmas bordas: mês que
+ * começa no domingo, fevereiro de ano comum, virada de ano.
+ *
+ * 6 linhas fixas e não "as que precisar": grade que muda de altura ao navegar
+ * de mês faz o conteúdo abaixo pular.
+ */
+export declare function buildMonthMatrix(anchor: Date, weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6): Date[][];
+/**
+ * Quantos chips cabem numa célula do mês, e quantos sobram.
+ *
+ * ⚠️ Duplicado do `Scheduler` pelo mesmo motivo acima.
+ *
+ * A linha "+N mais" ocupa **um slot do mesmo tamanho de um chip** — por isso
+ * `visible` é `max - 1` quando há estouro. Ignorar isso faz o último chip ser
+ * empurrado pra fora da célula pela própria linha de estouro.
+ *
+ * E o estouro só existe a partir de `total > max`: com exatamente `max` itens,
+ * mostrar `max - 1` + "+1 mais" seria trocar um chip por um aviso.
+ */
+export declare function computeOverflow(total: number, max: number): {
+    visible: number;
+    overflowCount: number;
+};
+/**
+ * Dias que uma barra ocupa dentro de um mês — pra virar chip em cada dia.
+ *
+ * ⚠️ Duplicado do `segmentMultiDay` do `Scheduler`, mesmo motivo.
+ *
+ * A guarda de 400 iterações existe porque `end` anterior a `start` (dado sujo)
+ * faria o `while` nunca terminar. Devolve vazio nesse caso, não loop infinito.
+ */
+export declare function daysOfBar(bar: GanttBar): Date[];
+/** Último dia visível da matriz, pra recortar barras na visão de mês. */
+export declare function monthMatrixRange(weeks: Date[][]): {
+    start: Date;
+    end: Date;
+};
+/** Fim do mês âncora — pra distinguir dia "de fora" na grade. */
+export declare function monthBounds(anchor: Date): {
+    start: Date;
+    end: Date;
+};
+//# sourceMappingURL=layout.d.ts.map

package/dist-lib/src/components/ui/Gantt/hooks/layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/hooks/layout.ts"],"names":[],"mappings":"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"}

package/dist-lib/src/components/ui/Gantt/hooks/links.d.ts

@@ -0,0 +1,120 @@
+import { GanttBar, GanttLink, GanttLinkType, GanttLinkViolation } from '../gantt.types';
+/**
+ * Grafo de vínculos do `Gantt` — **puro**: sem React, sem DOM.
+ *
+ * É a parte que distingue Gantt de timeline. Sem isto o componente mostra
+ * tarefas com datas; com isto mostra um modelo de como o projeto funciona.
+ *
+ * ## O componente VALIDA e SINALIZA. Não corrige.
+ *
+ * Nenhuma função aqui devolve datas novas. Vínculo violado vira
+ * `GanttLinkViolation`, que a raiz emite em `onLinkViolations` e a barra pinta
+ * com marcação de conflito.
+ *
+ * Corrigir cronograma é decisão de negócio: mover a tarefa que atrasou, cortar
+ * escopo, aceitar o atraso ou renegociar o vínculo são quatro respostas
+ * diferentes pro mesmo conflito, e o componente não tem como escolher. É a
+ * mesma posição do `onEventMove` do `Scheduler` e do `onCardMove` do `Kanban` —
+ * o DS é dumb sobre mutação por princípio, e aqui isso vale em dobro porque o
+ * erro seria invisível: datas reescritas sozinhas parecem dados.
+ */
+/**
+ * A borda de cada tipo de vínculo — a data que o `target` não pode violar.
+ *
+ * | Tipo | Restrição                           |
+ * |------|-------------------------------------|
+ * | `FS` | `target.start ≥ source.end   + lag` |
+ * | `SS` | `target.start ≥ source.start + lag` |
+ * | `FF` | `target.end   ≥ source.end   + lag` |
+ * | `SF` | `target.end   ≥ source.start + lag` |
+ *
+ * A primeira letra diz de qual ponta do `source` sai; a segunda, qual ponta do
+ * `target` é restringida. `FS` = sai do Finish, restringe o Start.
+ */
+export declare function constraintDates(tipo: GanttLinkType, source: GanttBar, target: GanttBar, lag?: number): {
+    limite: Date;
+    pontaAlvo: Date;
+};
+/**
+ * Confere um vínculo contra as datas atuais.
+ *
+ * `null` = satisfeito. Caso contrário, `deficitDays` é o quanto o alvo teria que
+ * andar pra frente — número que a mensagem de erro usa e que o consumidor pode
+ * aplicar se quiser corrigir.
+ *
+ * ⚠️ Vínculo cujo `source` ou `target` não existe no conjunto de barras é
+ * **ignorado**, não reportado como violação. Referência pendente acontece
+ * durante paginação e durante edição otimista; tratar como conflito encheria a
+ * tela de falso positivo em estado transitório.
+ */
+export declare function checkLink(link: GanttLink, bars: ReadonlyMap<string, GanttBar>): GanttLinkViolation | null;
+export declare function checkAllLinks(links: readonly GanttLink[], bars: ReadonlyMap<string, GanttBar>): GanttLinkViolation[];
+export type TopoResult = {
+    ok: true;
+    order: string[];
+} | {
+    ok: false;
+    cycle: string[];
+};
+/**
+ * Kahn sobre o grafo de barras. Base do caminho crítico.
+ *
+ * Devolve `ok: false` com os ids que sobraram quando há ciclo — e isso é
+ * **resultado**, não exceção. Ciclo é dado do consumidor, não bug do
+ * componente; lançar mataria a tela inteira por causa de dois vínculos
+ * invertidos. A raiz encaminha pra `onGraphError` e simplesmente não pinta
+ * caminho crítico.
+ *
+ * ⚠️ Auto-vínculo (`source === target`) conta como ciclo de um nó. Parece
+ * pedante, mas acontece: duplicar uma tarefa junto com seus vínculos produz
+ * exatamente isso, e sem a checagem o nó ficaria com grau de entrada 1 pra
+ * sempre e o algoritmo devolveria ordem incompleta em silêncio.
+ */
+export declare function topoSort(barIds: readonly string[], links: readonly GanttLink[]): TopoResult;
+/**
+ * Barras no caminho crítico — a sequência que determina a data final.
+ *
+ * Método: passagem pra frente calcula o começo mais cedo (`earlyStart`) de cada
+ * barra respeitando os vínculos; passagem pra trás calcula o mais tarde
+ * (`lateStart`) sem atrasar o projeto. Folga zero (`lateStart − earlyStart`) =
+ * crítica.
+ *
+ * ⚠️ **Só considera `FS`.** Os outros três tipos exigem tratar as duas pontas
+ * como nós independentes no grafo (o CPM clássico é sobre *atividade-em-nó* com
+ * início e fim separados), e implementar isso pela metade daria caminho crítico
+ * *plausível e errado* — que é pior que não ter. `SS`/`FF`/`SF` continuam sendo
+ * validados por `checkAllLinks`; só não entram no cálculo de criticidade.
+ *
+ * Registrado como limite conhecido na USAGE, não escondido.
+ */
+export declare function computeCriticalPath(bars: readonly GanttBar[], links: readonly GanttLink[]): {
+    critical: Set<string>;
+} | {
+    cycle: string[];
+};
+export type LinkAnchor = {
+    x: number;
+    y: number;
+};
+/**
+ * Path SVG entre duas barras, em ortogonal (só segmentos retos).
+ *
+ * Ortogonal e não curva de Bézier porque com 40 vínculos as curvas viram um
+ * emaranhado onde não se segue nenhuma; segmentos retos com cotovelo se leem
+ * mesmo cruzados. É o que todas as referências com muitos vínculos fazem.
+ *
+ * `saiDireita`/`entraEsquerda` derivam do TIPO: um `FS` sai da ponta direita do
+ * source e entra na esquerda do target; um `SS` sai da esquerda e entra na
+ * esquerda. Sem isso a seta de um `SS` sairia do lado errado e sugeriria FS.
+ */
+export declare function linkPath(de: LinkAnchor, para: LinkAnchor, opts: {
+    saiDireita: boolean;
+    entraEsquerda: boolean;
+    recuo?: number;
+}): string;
+/** Qual ponta de cada barra o vínculo conecta. */
+export declare function linkSides(tipo: GanttLinkType): {
+    saiDireita: boolean;
+    entraEsquerda: boolean;
+};
+//# sourceMappingURL=links.d.ts.map

package/dist-lib/src/components/ui/Gantt/hooks/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/hooks/links.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,aAAa,EACb,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;GAkBG;AAIH;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,QAAQ,EAChB,GAAG,SAAI,GACN;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAInC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,GAClC,kBAAkB,GAAG,IAAI,CAe3B;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,GAClC,kBAAkB,EAAE,CAOtB;AAID,MAAM,MAAM,UAAU,GAClB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC7B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEnC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B,UAAU,CAiCZ;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,KAAK,EAAE,SAAS,SAAS,EAAE,GAC1B;IAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAkEjD;AAWD,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CACtB,EAAE,EAAE,UAAU,EACd,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACpE,MAAM,CAiBR;AAED,kDAAkD;AAClD,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;CACxB,CAKA"}

package/dist-lib/src/components/ui/Gantt/hooks/week-segments.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Núcleo puro dos **segmentos de semana** da grade de mês — sem React, sem DOM.
+ *
+ * ## O problema que isto resolve
+ *
+ * A primeira versão da visão de calendário desenhava **um chip por dia**: uma
+ * tarefa de 10 a 15 aparecia como 6 chips soltos, um em cada célula, cada um
+ * repetindo o mesmo nome. Lê como seis tarefas de um dia, não como uma de seis —
+ * o oposto do que um cronograma precisa dizer.
+ *
+ * Aqui cada barra vira **um segmento contínuo por semana**, atravessando as
+ * colunas que ocupa. Uma tarefa que cruza a virada de semana produz dois
+ * segmentos, cada um marcado com `continuesBefore`/`continuesAfter` — é o mesmo
+ * vocabulário que o `clipToWindow` usa na timeline, e pela mesma razão: a ponta
+ * cortada tem que parecer intencional.
+ *
+ * ## Por que lane e não empilhamento por ordem
+ *
+ * Duas barras que ocupam colunas sobrepostas na mesma semana não podem dividir a
+ * mesma faixa vertical. A alocação é gulosa na primeira faixa livre, com as
+ * barras ordenadas por **coluna inicial e depois por span decrescente**: barra
+ * longa primeiro faz a mais comprida ficar na faixa de cima, que é como
+ * calendário de verdade se lê — o "guarda-chuva" acima dos eventos curtos.
+ *
+ * ⛔ Não reusa o `packLanes` do `layout.ts`: aquele empacota por DATA num eixo
+ * contínuo, e aqui o eixo é discreto (7 colunas) e reinicia a cada semana. Usar
+ * o mesmo daria lanes coerentes no mês e incoerentes na linha.
+ */
+export type GanttSegmentInput = {
+    id: string;
+    start: Date;
+    end: Date;
+};
+export type GanttWeekSegment = {
+    barId: string;
+    /** Coluna onde começa nesta semana, 0–6. */
+    colStart: number;
+    /** Quantas colunas ocupa nesta semana, 1–7. */
+    colSpan: number;
+    /** Faixa vertical dentro da linha da semana, 0 = a de cima. */
+    lane: number;
+    /** Começou antes do primeiro dia desta semana. */
+    continuesBefore: boolean;
+    /** Termina depois do último dia desta semana. */
+    continuesAfter: boolean;
+};
+/**
+ * Segmentos de UMA semana.
+ *
+ * `week` são os 7 dias na ordem em que a grade os mostra — vem do
+ * `buildMonthMatrix`, então `weekStartsOn` já está aplicado e esta função não
+ * precisa saber dele.
+ */
+export declare function buildWeekSegments(week: readonly Date[], barras: readonly GanttSegmentInput[]): GanttWeekSegment[];
+/**
+ * Quantos segmentos ficam escondidos em cada COLUNA quando só `maxLanes` faixas
+ * cabem na altura da linha.
+ *
+ * Devolve um array de 7 contagens — é o "+N mais" de cada dia.
+ *
+ * ⚠️ A contagem é por COLUNA e não por semana: uma barra escondida que ocupa 3
+ * dias tem que aparecer no "+N" dos três, senão o usuário que olha o dia 12 não
+ * descobre que existe algo ali. Somar por semana daria um número certo no total
+ * e errado em todas as células.
+ */
+export declare function hiddenPerColumn(segmentos: readonly GanttWeekSegment[], maxLanes: number, colunas?: number): number[];
+/** Quantas faixas a semana precisa pra mostrar tudo. */
+export declare function laneCount(segmentos: readonly GanttWeekSegment[]): number;
+//# sourceMappingURL=week-segments.d.ts.map

package/dist-lib/src/components/ui/Gantt/hooks/week-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"week-segments.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/hooks/week-segments.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;CACX,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,eAAe,EAAE,OAAO,CAAC;IACzB,iDAAiD;IACjD,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,IAAI,EAAE,EACrB,MAAM,EAAE,SAAS,iBAAiB,EAAE,GACnC,gBAAgB,EAAE,CAqEpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,SAAI,GACV,MAAM,EAAE,CAUV;AAED,wDAAwD;AACxD,wBAAgB,SAAS,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAIxE"}

package/dist-lib/src/components/ui/Gantt/index.d.ts

@@ -0,0 +1,46 @@
+export { Gantt } from './gantt';
+/**
+ * Partes exportadas soltas — mesmo padrão do `TableToolbar` e do
+ * `SchedulerFilterPanel`.
+ *
+ * Serve pra tela que queira posicionar a grade ou a camada de setas em outro
+ * lugar do próprio layout, e pra doc page mostrar a anatomia isolada. Em uso
+ * normal você não precisa delas: o `Gantt` monta e controla as suas.
+ */
+export { GanttGrid, GANTT_DEFAULT_COLUMNS } from './parts/gantt-grid';
+export type { GanttGridProps } from './parts/gantt-grid';
+export { GanttBarView, GANTT_BAR_MIN_WIDTH_PX } from './parts/gantt-bar';
+export type { GanttBarViewProps } from './parts/gantt-bar';
+export { GanttFilterPanel } from './parts/gantt-filter-panel';
+export type { GanttFilterPanelProps } from './parts/gantt-filter-panel';
+export { GanttLinksLayer } from './parts/gantt-links-layer';
+export type { GanttLinksLayerProps, GanttLinkGeometry, } from './parts/gantt-links-layer';
+/**
+ * Núcleo puro. Exportado porque é útil fora do render: validar um cronograma no
+ * servidor, calcular caminho crítico num job, testar regra de negócio sem
+ * montar React.
+ */
+export { buildTimeAxis, buildMonthMatrix, clipToWindow, computeOverflow, dateToDayOffset, dateToX, daysOfBar, deriveSummaryRange, deriveWindow, flattenRows, monthBounds, monthMatrixRange, packLanes, rowHeights, rowOffsets, snapDate, xToDate, } from './hooks/layout';
+export type { GanttAxis, GanttClippedBar, GanttFlatRow, GanttTick, } from './hooks/layout';
+export { checkAllLinks, checkLink, computeCriticalPath, constraintDates, linkPath, linkSides, topoSort, } from './hooks/links';
+export type { LinkAnchor, TopoResult } from './hooks/links';
+export { GANTT_ROW_HEIGHT_PX, GANTT_LANE_HEIGHT_PX, GANTT_HEAD_HEIGHT_PX, GANTT_PX_PER_DAY, } from './gantt.styles';
+/**
+ * O `tv()` do segmento da grade de mês — a "pílula" que representa a tarefa num
+ * dia, com ponto de cor, rótulo e o tingimento do `colorKey`.
+ *
+ * Exportado por um motivo específico: **prever como o item vai ficar antes de
+ * criá-lo**. Um formulário de nova tarefa que ofereça escolha de cor precisa
+ * mostrar a escolha, e desenhar isso na mão no consumidor recria o único
+ * defeito que a prévia existe pra evitar — duas definições da mesma pílula, que
+ * divergem na primeira vez que uma das duas mudar.
+ *
+ * Slots: `root` · `dot` · `label`. Variantes: `colorKey`, `continuesBefore`,
+ * `continuesAfter`, `conflict`, `critical`.
+ *
+ * ⚠️ O `root` é `absolute` porque na grade ele é posicionado por `left`/`top`
+ * dentro da semana. Fora dela, neutralize: `root({ class: "relative w-full" })`.
+ */
+export { ganttDaySegment } from './gantt.styles';
+export type { GanttProps, GanttRef, GanttRow, GanttRowType, GanttBar, GanttBarChange, GanttColorKey, GanttColumn, GanttFilterField, GanttFilterModel, GanttFilterOption, GanttGranularity, GanttLink, GanttLinkType, GanttLinkViolation, GanttView, } from './gantt.types';
+//# sourceMappingURL=index.d.ts.map

package/dist-lib/src/components/ui/Gantt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/ui/Gantt/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;;;;;;GAOG;AACH,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACtE,YAAY,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACzE,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,YAAY,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,YAAY,EACV,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,2BAA2B,CAAC;AAEnC;;;;GAIG;AACH,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,OAAO,EACP,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,UAAU,EACV,QAAQ,EACR,OAAO,GACR,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,SAAS,EACT,eAAe,EACf,YAAY,EACZ,SAAS,GACV,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,aAAa,EACb,SAAS,EACT,mBAAmB,EACnB,eAAe,EACf,QAAQ,EACR,SAAS,EACT,QAAQ,GACT,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,YAAY,EACV,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,aAAa,EACb,kBAAkB,EAClB,SAAS,GACV,MAAM,eAAe,CAAC"}

package/dist-lib/src/components/ui/Gantt/parts/gantt-applied-filters.d.ts

@@ -0,0 +1,20 @@
+import { GanttFilterField, GanttFilterModel } from '../gantt.types';
+export type GanttAppliedFiltersProps = {
+    fields: GanttFilterField[];
+    model: GanttFilterModel;
+    /** Todas as linhas — a contagem por opção é sobre elas, não sobre as filtradas. */
+    counts: Record<string, Record<string, number>>;
+    onToggleValue: (fieldId: string, value: string) => void;
+    onClearField: (fieldId: string) => void;
+    onClearAll: () => void;
+    /**
+     * Formata o ISO de um filtro `date` pro chip.
+     *
+     * Vem da raiz porque é lá que o `locale` mora — o chip não deve mostrar
+     * "2026-09-01" a um usuário pt-BR, e formatar aqui na unha significaria uma
+     * segunda decisão de formato de data no mesmo componente.
+     */
+    formatDate?: (iso: string) => string;
+};
+export declare function GanttAppliedFilters({ fields, model, counts, onToggleValue, onClearField, onClearAll, formatDate, }: GanttAppliedFiltersProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=gantt-applied-filters.d.ts.map

package/dist-lib/src/components/ui/Gantt/parts/gantt-applied-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gantt-applied-filters.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/parts/gantt-applied-filters.tsx"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAsDzE,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,mFAAmF;IACnF,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC/C,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CACtC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,EAClC,MAAM,EACN,KAAK,EACL,MAAM,EACN,aAAa,EACb,YAAY,EACZ,UAAU,EACV,UAAU,GACX,EAAE,wBAAwB,kDA4I1B"}

package/dist-lib/src/components/ui/Gantt/parts/gantt-bar.d.ts

@@ -0,0 +1,68 @@
+import { CSSProperties, MouseEvent, ReactNode } from 'react';
+import { GanttBar, GanttColorKey, GanttRowType } from '../gantt.types';
+/**
+ * A barra — e o losango do marco, que é a mesma peça noutro formato.
+ *
+ * ## Posicionada em px absoluto, não em grid
+ *
+ * `left`/`width` vêm de `dateToX`. Grid de N colunas parece mais limpo até a
+ * primeira barra que começa às 14h de um dia: ela não cai em limite de coluna, e
+ * a alternativa (arredondar pro dia) apaga informação que o consumidor passou.
+ *
+ * ## Largura mínima, e por que não é estética
+ *
+ * Uma barra de 1 dia em granularidade `quarter` tem **1,6px**. Sem piso, ela
+ * some — e "some" é indistinguível de "não existe", que é o pior modo de falha
+ * pra quem está conferindo se a tarefa entrou no plano. O piso de 6px mantém a
+ * barra clicável e visível, ao custo de exagerar a duração nessa escala.
+ */
+export declare const GANTT_BAR_MIN_WIDTH_PX = 6;
+export type GanttBarViewProps = {
+    bar: GanttBar;
+    /** Posição já calculada pela view — a barra não sabe converter data. */
+    left: number;
+    width: number;
+    /** Índice da lane dentro da linha (0 na maioria dos casos). */
+    lane: number;
+    rowType: GanttRowType;
+    colorKey: GanttColorKey;
+    continuesBefore: boolean;
+    continuesAfter: boolean;
+    conflict?: boolean;
+    critical?: boolean;
+    /**
+     * Altura em px, decidida pela VIEW e não aqui.
+     *
+     * A view é quem sabe se a linha tem uma lane ou cinco, e portanto quanto
+     * espaço a barra pode ocupar. Deixar a barra escolher faria ela precisar
+     * conhecer o `lanePacking` da linha — informação que não é dela.
+     */
+    height: number;
+    movable?: boolean;
+    resizable?: boolean;
+    linkable?: boolean;
+    dragging?: boolean;
+    onClick?: (evt: MouseEvent) => void;
+    /**
+     * Início do gesto de MOVER — `pointerdown` no corpo da barra.
+     *
+     * ⚠️ Só no corpo: os punhos de resize e as portas de vínculo dão
+     * `stopPropagation`, senão um `pointerdown` no punho iniciaria os dois
+     * gestos ao mesmo tempo e a barra moveria enquanto redimensiona.
+     */
+    onMoveStart?: (evt: MouseEvent) => void;
+    /** Início do gesto de resize. `side` diz qual ponta. */
+    onResizeStart?: (side: "start" | "end", evt: MouseEvent) => void;
+    /** Início do gesto de criar vínculo. */
+    onLinkStart?: (side: "start" | "end", evt: MouseEvent) => void;
+    /** Render custom do conteúdo — substitui o rótulo default. */
+    children?: ReactNode;
+    style?: CSSProperties;
+};
+/**
+ * ⚠️ `forwardRef` porque o dnd-kit precisa do nó DOM (`setNodeRef`), e porque a
+ * barra é âncora de `Tooltip`/`Popover` — sem ref, `asChild` do Radix não obtém
+ * o nó e o flutuante ancora fora do viewport (L-021, medido).
+ */
+export declare const GanttBarView: import('react').ForwardRefExoticComponent<GanttBarViewProps & import('react').RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=gantt-bar.d.ts.map

package/dist-lib/src/components/ui/Gantt/parts/gantt-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gantt-bar.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/parts/gantt-bar.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAOxF,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,QAAQ,CAAC;IACd,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;IACtB,QAAQ,EAAE,aAAa,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IAExB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IACpC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IACxC,wDAAwD;IACxD,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IACjE,wCAAwC;IACxC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,EAAE,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IAE/D,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,KAAK,CAAC,EAAE,aAAa,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,8GAmKxB,CAAC"}

package/dist-lib/src/components/ui/Gantt/parts/gantt-filter-panel.d.ts

@@ -0,0 +1,16 @@
+import { GanttFilterField, GanttFilterModel } from '../gantt.types';
+export type GanttFilterPanelProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    fields: GanttFilterField[];
+    model: GanttFilterModel;
+    onToggleValue: (fieldId: string, value: string) => void;
+    /** Marca ou desmarca o grupo inteiro de uma vez. */
+    onSetFieldValues: (fieldId: string, values: string[]) => void;
+    onClearAll: () => void;
+    appliedCount: number;
+    /** Contagem por opção — vem das linhas ANTES do filtro daquele campo. */
+    counts?: Record<string, Record<string, number>>;
+};
+export declare function GanttFilterPanel({ open, onOpenChange, fields, model, onToggleValue, onSetFieldValues, onClearAll, appliedCount, counts, }: GanttFilterPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=gantt-filter-panel.d.ts.map

package/dist-lib/src/components/ui/Gantt/parts/gantt-filter-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gantt-filter-panel.d.ts","sourceRoot":"","sources":["../../../../../../src/components/ui/Gantt/parts/gantt-filter-panel.tsx"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA8CzE,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,EAAE,gBAAgB,CAAC;IACxB,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD,oDAAoD;IACpD,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IAC9D,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,KAAK,EACL,aAAa,EACb,gBAAgB,EAChB,UAAU,EACV,YAAY,EACZ,MAAM,GACP,EAAE,qBAAqB,2CA+DvB"}