@meistrari/minuta-editor 1.5.0 → 1.6.0

package/README.md

@@ -61,6 +61,13 @@ editor.setImageFallback('dataUri' | 'none')
 editor.variablesInDocument()             // → string[]
 editor.refreshVaultImages(vaultUrl => Promise<string>) // renova o src das imagens do vault (data-vault-src ou src="vault://"); sem undo/onChange
 
+// checklist junto da edição (o documento gerado vem do GET /data/case/:id/html?source=blocks)
+editor.stampGenerated()                  // ao CRIAR a edição a partir do HTML do checklist: marca os blocos como "gerados"
+editor.applyChecklist(htmlGerado, { toggled? }) // → { inserted, removed, regenerated, variablesUpdated, conflicts, … }
+editor.checklistConflicts()              // → [{ blockId, blockTitle, kind: 'replace' | 'remove' }]
+editor.resolveChecklistConflict(blockId, 'keep' | 'apply')
+editor.documentBlockIds()                // → blocos no texto, na ordem
+
 editor.schedulePaginate() // repagina (após mudar algo que afeta altura por fora)
 editor.totalPages()
 editor.destroy()

package/dist/index.d.mts

@@ -22,7 +22,7 @@ import { Transaction } from '@tiptap/pm/state';
 import { EditorView } from '@tiptap/pm/view';
 import { P as PocPageConfig } from './shared/minuta-editor.9e65d163.mjs';
 export { e as PAGINATE_META, a as PocDocxChrome, b as PocDocxExportOptions, s as PocLoneRow, d as PocPageBreak, c as PocPageNote, v as PocPaginationPlugin, u as breaksEqual, h as buildPocFooterEl, g as buildPocHeaderEl, j as buildPocNotesEl, l as computePocBreaks, t as computePocLoneRows, i as isPocChromeCanvas, n as isPocFlexRow, f as pocChromeFlowHeight, m as pocDescendsInto, r as pocLoneCellIndex, k as pocLooksLikeTitle, o as pocNodeHasVisibleContent, q as pocNodePaintsBox, p as pocPageKey } from './shared/minuta-editor.9e65d163.mjs';
-import '@tiptap/pm/model';
+import { Node as Node$1 } from '@tiptap/pm/model';
 
 /**
  * Variáveis de template da minuta — o formato do placeholder e a resolução dele.
@@ -206,6 +206,84 @@ declare function buildPocExtensions(pageConfig?: PocPageConfig, options?: {
     handleKeyDown?: (view: EditorView, event: KeyboardEvent) => boolean;
 }): (Node<any, any> | Extension<any, any> | Mark<any, any>)[];
 
+/**
+ * Impressão digital de um bloco da minuta (nó `minutaBlock` do editor) — base
+ * de "o advogado mexeu neste trecho?" quando o checklist muda com uma edição
+ * viva. O bloco nasce com `genHash` = impressão do texto gerado; enquanto a
+ * impressão atual bater com ela, o trecho é do checklist e pode ser
+ * re-gerado sem perder nada.
+ *
+ * Fica de fora o que muda SEM o advogado editar:
+ * - URL descartável de imagem (blob:/placeholder do load progressivo/vault:// do
+ *   save): a imagem entra pela identidade DURÁVEL (`imageIdentity`), então
+ *   trocar a imagem de verdade muda a impressão;
+ * - número de tópico e de nota (re-sequenciam quando outro trecho muda);
+ * - valor das variáveis (o chip é atualizado no lugar, em qualquer bloco —
+ *   inclusive dentro de lista/tabela guardada como HTML cru).
+ *
+ * Mesma regra em `client/utils/minutaBlockFingerprint.ts` (o app ainda mantém a
+ * cópia dele) — a impressão gravada por um tem que bater com a do outro.
+ *
+ * Recebe o JSON do nó (`node.toJSON()`), então é pura e não depende de DOM.
+ */
+interface NodeJson {
+    type: string;
+    attrs?: Record<string, any>;
+    content?: NodeJson[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+    }[];
+    text?: string;
+}
+/**
+ * Identidade durável de uma imagem a partir do `src` (e do `data-vault-src` do
+ * placeholder do load progressivo) — no app, blob: do cache → vault://.
+ */
+type ImageIdentity = (src: string) => string;
+declare function minutaBlockFingerprint(blockJson: NodeJson, identity?: ImageIdentity): string;
+
+/**
+ * Checklist × edição viva, para quem usa o editor fora do defesa.ai.
+ *
+ * O documento editado continua dividido em `minutaBlock` (um por bloco do
+ * template, `isolating`), e cada bloco guarda em `genHash` a impressão digital
+ * do texto que o checklist gerou. Com isso, quando o checklist muda (tese que
+ * passou a valer, variável alterada), dá para aplicar a mudança SÓ onde ela
+ * cai, sem passar por cima do que o advogado escreveu:
+ *
+ * - tese que passou a gerar texto → o bloco entra na posição do template;
+ * - tese que deixou de gerar → o bloco sai (se foi editado, vira conflito);
+ * - variável alterada → o chip atualiza no lugar, em qualquer bloco;
+ * - bloco cuja ESTRUTURA mudou → re-gerado se ninguém o editou, conflito se sim.
+ *
+ * Mesma lógica de `client/composables/poc/pocEditionSync.ts` + o
+ * `syncEditionWithChecklist` do app; aqui o documento gerado chega pronto (o
+ * `GET /data/case/:id/html?source=blocks`), em vez de renderizado no browser.
+ */
+interface MinutaChecklistConflict {
+    blockId: string;
+    blockTitle: string | null;
+    /** `replace`: o checklist mudou o texto de um trecho editado; `remove`: desligou uma tese editada */
+    kind: 'replace' | 'remove';
+}
+interface MinutaChecklistResult {
+    inserted: string[];
+    removed: string[];
+    regenerated: string[];
+    /** quantos chips de variável mudaram de valor */
+    variablesUpdated: number;
+    /** conflitos abertos depois desta aplicação (inclui os que já estavam) */
+    conflicts: MinutaChecklistConflict[];
+    /** a tese pedida em `toggled.show` não gera texto (condições internas) */
+    toggledWithoutContent: boolean;
+    /** a remoção não aconteceu porque o documento ficaria sem nenhum bloco */
+    lastBlockKept: boolean;
+}
+declare function blockHash(node: Node$1, identity?: ImageIdentity): string;
+/** o conteúdo ainda é o que o checklist gerou (sem `genHash` = editado, por segurança) */
+declare function isBlockUntouched(node: Node$1, identity?: ImageIdentity): boolean;
+
 /**
  * O editor de minuta como coisa montável em qualquer lugar: `createMinutaEditor(el, opts)`.
  *
@@ -374,6 +452,35 @@ interface MinutaEditor {
      * guarda uma cópia do documento.
      */
     refreshVaultImages: (resolveUrl: (vaultUrl: string) => Promise<string>) => Promise<number>;
+    /**
+     * Checklist junto da edição: aplica o documento GERADO pelo checklist agora
+     * (o `GET /data/case/:id/html?source=blocks`) sobre o documento editado,
+     * bloco a bloco — tese que passou a valer entra na posição do template, a
+     * que deixou de valer sai, variáveis atualizam no lugar e trecho cuja
+     * estrutura mudou é re-gerado só se ninguém o editou (senão vira conflito).
+     * `toggled` força a decisão de UMA tese (o host ligou/desligou na mão).
+     * Uma transação só: o desfazer volta tudo. Blocos novos (e os aceitos em
+     * `resolveChecklistConflict`) podem trazer imagem `vault://` — chame
+     * `refreshVaultImages` depois de aplicar E de resolver os conflitos.
+     */
+    applyChecklist: (generatedHtml: string, options?: {
+        toggled?: {
+            blockId: string;
+            show: boolean;
+        };
+    }) => MinutaChecklistResult;
+    /** trechos editados que o checklist quer mudar e aguardam decisão do advogado */
+    checklistConflicts: () => MinutaChecklistConflict[];
+    /** `apply` usa o texto novo (ou remove); `keep` mantém o editado e não pergunta de novo pela mesma mudança */
+    resolveChecklistConflict: (blockId: string, resolution: 'keep' | 'apply') => boolean;
+    /**
+     * Marca todos os blocos como "texto gerado". Chame UMA vez ao criar a edição
+     * a partir do HTML do checklist — sem a marca, todo bloco conta como editado
+     * e o `applyChecklist` pergunta em vez de re-gerar. Devolve quantos marcou.
+     */
+    stampGenerated: () => number;
+    /** blocos (`data-block-id`) no documento, na ordem — para o checklist mostrar o que está no texto */
+    documentBlockIds: () => string[];
     /** repagina (o host chama após mudar algo que afeta altura fora do editor) */
     schedulePaginate: () => void;
     /** reconstrói cabeçalhos/rodapés com o chrome atual, sem repaginar */
@@ -561,5 +668,5 @@ declare function collectVaultRefs(html: string): string[];
 /** aplica as URLs resolvidas às `<img>` do trecho; tags sem resolução ficam como estão */
 declare function renewVaultImageTags(html: string, resolved: Map<string, string>): string;
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
-export type { FootnoteRun, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, isBlockUntouched, minutaBlockFingerprint, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
+export type { FootnoteRun, ImageIdentity, MinutaChecklistConflict, MinutaChecklistResult, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };

package/dist/index.d.ts

@@ -22,7 +22,7 @@ import { Transaction } from '@tiptap/pm/state';
 import { EditorView } from '@tiptap/pm/view';
 import { P as PocPageConfig } from './shared/minuta-editor.9e65d163.js';
 export { e as PAGINATE_META, a as PocDocxChrome, b as PocDocxExportOptions, s as PocLoneRow, d as PocPageBreak, c as PocPageNote, v as PocPaginationPlugin, u as breaksEqual, h as buildPocFooterEl, g as buildPocHeaderEl, j as buildPocNotesEl, l as computePocBreaks, t as computePocLoneRows, i as isPocChromeCanvas, n as isPocFlexRow, f as pocChromeFlowHeight, m as pocDescendsInto, r as pocLoneCellIndex, k as pocLooksLikeTitle, o as pocNodeHasVisibleContent, q as pocNodePaintsBox, p as pocPageKey } from './shared/minuta-editor.9e65d163.js';
-import '@tiptap/pm/model';
+import { Node as Node$1 } from '@tiptap/pm/model';
 
 /**
  * Variáveis de template da minuta — o formato do placeholder e a resolução dele.
@@ -206,6 +206,84 @@ declare function buildPocExtensions(pageConfig?: PocPageConfig, options?: {
     handleKeyDown?: (view: EditorView, event: KeyboardEvent) => boolean;
 }): (Node<any, any> | Extension<any, any> | Mark<any, any>)[];
 
+/**
+ * Impressão digital de um bloco da minuta (nó `minutaBlock` do editor) — base
+ * de "o advogado mexeu neste trecho?" quando o checklist muda com uma edição
+ * viva. O bloco nasce com `genHash` = impressão do texto gerado; enquanto a
+ * impressão atual bater com ela, o trecho é do checklist e pode ser
+ * re-gerado sem perder nada.
+ *
+ * Fica de fora o que muda SEM o advogado editar:
+ * - URL descartável de imagem (blob:/placeholder do load progressivo/vault:// do
+ *   save): a imagem entra pela identidade DURÁVEL (`imageIdentity`), então
+ *   trocar a imagem de verdade muda a impressão;
+ * - número de tópico e de nota (re-sequenciam quando outro trecho muda);
+ * - valor das variáveis (o chip é atualizado no lugar, em qualquer bloco —
+ *   inclusive dentro de lista/tabela guardada como HTML cru).
+ *
+ * Mesma regra em `client/utils/minutaBlockFingerprint.ts` (o app ainda mantém a
+ * cópia dele) — a impressão gravada por um tem que bater com a do outro.
+ *
+ * Recebe o JSON do nó (`node.toJSON()`), então é pura e não depende de DOM.
+ */
+interface NodeJson {
+    type: string;
+    attrs?: Record<string, any>;
+    content?: NodeJson[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+    }[];
+    text?: string;
+}
+/**
+ * Identidade durável de uma imagem a partir do `src` (e do `data-vault-src` do
+ * placeholder do load progressivo) — no app, blob: do cache → vault://.
+ */
+type ImageIdentity = (src: string) => string;
+declare function minutaBlockFingerprint(blockJson: NodeJson, identity?: ImageIdentity): string;
+
+/**
+ * Checklist × edição viva, para quem usa o editor fora do defesa.ai.
+ *
+ * O documento editado continua dividido em `minutaBlock` (um por bloco do
+ * template, `isolating`), e cada bloco guarda em `genHash` a impressão digital
+ * do texto que o checklist gerou. Com isso, quando o checklist muda (tese que
+ * passou a valer, variável alterada), dá para aplicar a mudança SÓ onde ela
+ * cai, sem passar por cima do que o advogado escreveu:
+ *
+ * - tese que passou a gerar texto → o bloco entra na posição do template;
+ * - tese que deixou de gerar → o bloco sai (se foi editado, vira conflito);
+ * - variável alterada → o chip atualiza no lugar, em qualquer bloco;
+ * - bloco cuja ESTRUTURA mudou → re-gerado se ninguém o editou, conflito se sim.
+ *
+ * Mesma lógica de `client/composables/poc/pocEditionSync.ts` + o
+ * `syncEditionWithChecklist` do app; aqui o documento gerado chega pronto (o
+ * `GET /data/case/:id/html?source=blocks`), em vez de renderizado no browser.
+ */
+interface MinutaChecklistConflict {
+    blockId: string;
+    blockTitle: string | null;
+    /** `replace`: o checklist mudou o texto de um trecho editado; `remove`: desligou uma tese editada */
+    kind: 'replace' | 'remove';
+}
+interface MinutaChecklistResult {
+    inserted: string[];
+    removed: string[];
+    regenerated: string[];
+    /** quantos chips de variável mudaram de valor */
+    variablesUpdated: number;
+    /** conflitos abertos depois desta aplicação (inclui os que já estavam) */
+    conflicts: MinutaChecklistConflict[];
+    /** a tese pedida em `toggled.show` não gera texto (condições internas) */
+    toggledWithoutContent: boolean;
+    /** a remoção não aconteceu porque o documento ficaria sem nenhum bloco */
+    lastBlockKept: boolean;
+}
+declare function blockHash(node: Node$1, identity?: ImageIdentity): string;
+/** o conteúdo ainda é o que o checklist gerou (sem `genHash` = editado, por segurança) */
+declare function isBlockUntouched(node: Node$1, identity?: ImageIdentity): boolean;
+
 /**
  * O editor de minuta como coisa montável em qualquer lugar: `createMinutaEditor(el, opts)`.
  *
@@ -374,6 +452,35 @@ interface MinutaEditor {
      * guarda uma cópia do documento.
      */
     refreshVaultImages: (resolveUrl: (vaultUrl: string) => Promise<string>) => Promise<number>;
+    /**
+     * Checklist junto da edição: aplica o documento GERADO pelo checklist agora
+     * (o `GET /data/case/:id/html?source=blocks`) sobre o documento editado,
+     * bloco a bloco — tese que passou a valer entra na posição do template, a
+     * que deixou de valer sai, variáveis atualizam no lugar e trecho cuja
+     * estrutura mudou é re-gerado só se ninguém o editou (senão vira conflito).
+     * `toggled` força a decisão de UMA tese (o host ligou/desligou na mão).
+     * Uma transação só: o desfazer volta tudo. Blocos novos (e os aceitos em
+     * `resolveChecklistConflict`) podem trazer imagem `vault://` — chame
+     * `refreshVaultImages` depois de aplicar E de resolver os conflitos.
+     */
+    applyChecklist: (generatedHtml: string, options?: {
+        toggled?: {
+            blockId: string;
+            show: boolean;
+        };
+    }) => MinutaChecklistResult;
+    /** trechos editados que o checklist quer mudar e aguardam decisão do advogado */
+    checklistConflicts: () => MinutaChecklistConflict[];
+    /** `apply` usa o texto novo (ou remove); `keep` mantém o editado e não pergunta de novo pela mesma mudança */
+    resolveChecklistConflict: (blockId: string, resolution: 'keep' | 'apply') => boolean;
+    /**
+     * Marca todos os blocos como "texto gerado". Chame UMA vez ao criar a edição
+     * a partir do HTML do checklist — sem a marca, todo bloco conta como editado
+     * e o `applyChecklist` pergunta em vez de re-gerar. Devolve quantos marcou.
+     */
+    stampGenerated: () => number;
+    /** blocos (`data-block-id`) no documento, na ordem — para o checklist mostrar o que está no texto */
+    documentBlockIds: () => string[];
     /** repagina (o host chama após mudar algo que afeta altura fora do editor) */
     schedulePaginate: () => void;
     /** reconstrói cabeçalhos/rodapés com o chrome atual, sem repaginar */
@@ -561,5 +668,5 @@ declare function collectVaultRefs(html: string): string[];
 /** aplica as URLs resolvidas às `<img>` do trecho; tags sem resolução ficam como estão */
 declare function renewVaultImageTags(html: string, resolved: Map<string, string>): string;
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
-export type { FootnoteRun, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPageConfig, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, buildPocExtensions, collectVaultRefs, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, formatTopicNumber, fromRoman, iconSvg, isBlockUntouched, minutaBlockFingerprint, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, swapVaultSrc, toRoman, topicNumberHtml, variableChipHtml, vaultImageHtml, vaultRefOf };
+export type { FootnoteRun, ImageIdentity, MinutaChecklistConflict, MinutaChecklistResult, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem, RefreshVaultImagesOptions, TopicNumberInfo, VariableClickKind };

package/dist/index.mjs

@@ -24,6 +24,8 @@ import TableRow from '@tiptap/extension-table-row';
 import { Plugin } from '@tiptap/pm/state';
 import { s as sanitizeRichHtml, e as sanitizeFootnoteHtml, g as footnoteSizePt, T as TOPIC_DEFAULT_GROUP, h as TOPIC_NUMBER_ATTR, r as readTopicNumber, i as TOPIC_GROUP_ATTR, j as TOPIC_ROMAN_ATTR, k as TOPIC_REF_ATTR, a as formatTopicNumber, P as PocPaginationPlugin, l as computePocBreaks, m as pocPageKey, n as breaksEqual, o as PAGINATE_META } from './shared/minuta-editor.f1239e0b.mjs';
 export { v as buildPocFooterEl, u as buildPocHeaderEl, w as buildPocNotesEl, z as computePocLoneRows, f as footnoteHtmlToRuns, C as fromRoman, t as isPocChromeCanvas, y as isPocFlexRow, q as pocChromeFlowHeight, x as pocDescendsInto, p as pocLoneCellIndex, b as pocLooksLikeTitle, c as pocNodeHasVisibleContent, d as pocNodePaintsBox, A as shouldMoveBreakToHeading, B as toRoman, D as topicNumberHtml } from './shared/minuta-editor.f1239e0b.mjs';
+import { closeHistory } from '@tiptap/pm/history';
+import { DOMParser } from '@tiptap/pm/model';
 import '@tiptap/pm/view';
 
 const POC_ASSET_SWAP = "pocAssetSwap";
@@ -35,7 +37,18 @@ function htmlToDom(html) {
 const PocDocument = Node$1.create({
   name: "doc",
   topNode: true,
-  content: "minutaBlock+"
+  content: "minutaBlock+",
+  addAttributes() {
+    return {
+      /**
+       * Estado do checklist × edição (engine/checklistSync): teses que o
+       * checklist queria no texto na última aplicação + conflitos abertos.
+       * Vive NO documento para o desfazer do editor voltar junto com o
+       * texto; não vai para o HTML (sem documento salvo, nasce do texto).
+       */
+      checklist: { default: null, rendered: false, parseHTML: () => null }
+    };
+  }
 });
 const PocMinutaBlock = Node$1.create({
   name: "minutaBlock",
@@ -291,6 +304,14 @@ const PocVariableChip = Node$1.create({
     return {
       variableId: { default: null },
       parentBlockId: { default: null },
+      /**
+       * linha do `<for>` — distingue a mesma variável em linhas diferentes
+       * (`data-loop-index` do app; `data-variable-index` da Data API)
+       */
+      loopIndex: {
+        default: null,
+        parseHTML: (el) => el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index")
+      },
       html: { default: "" },
       text: { default: "" }
     };
@@ -302,6 +323,7 @@ const PocVariableChip = Node$1.create({
       getAttrs: (el) => ({
         variableId: el.getAttribute("data-variable-id"),
         parentBlockId: el.getAttribute("data-parent-block-id"),
+        loopIndex: el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index"),
         html: el.outerHTML,
         text: el.textContent ?? ""
       })
@@ -728,7 +750,7 @@ const VARIABLE_TAG_RE = /<span\b[^>]*\bdata-minuta-var="([^"]*)"[^>]*>[^<]*<\/sp
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function decodeAttr(value) {
+function decodeAttr$1(value) {
   return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
 }
 function extractTemplateVariables(html) {
@@ -736,7 +758,7 @@ function extractTemplateVariables(html) {
     return [];
   const keys = [];
   for (const match of html.matchAll(VARIABLE_TAG_RE)) {
-    const key = decodeAttr(match[1] ?? "").trim();
+    const key = decodeAttr$1(match[1] ?? "").trim();
     if (key && !keys.includes(key))
       keys.push(key);
   }
@@ -747,7 +769,7 @@ function resolveTemplateVariables(html, values) {
     return { html: "", missing: [] };
   const missing = [];
   const resolved = html.replace(VARIABLE_TAG_RE, (tag, rawKey) => {
-    const key = decodeAttr(rawKey ?? "").trim();
+    const key = decodeAttr$1(rawKey ?? "").trim();
     if (!key)
       return tag;
     const value = values?.[key];
@@ -864,6 +886,362 @@ async function refreshVaultImages(editor, resolveUrl, options = {}) {
   return touched;
 }
 
+const IMG_TAG = /<img\b[^>]*>/g;
+const ATTR = (name) => new RegExp(`\\s${name}="([^"]*)"`);
+function decodeAttr(value) {
+  return value.replace(/&quot;/g, '"').replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function normalizeImgTags(html, identity) {
+  if (!html.includes("<img"))
+    return html;
+  return html.replace(IMG_TAG, (tag) => {
+    const vault = tag.match(ATTR("data-vault-src"))?.[1];
+    const src = tag.match(ATTR("src"))?.[1] ?? "";
+    const id = vault ? decodeAttr(vault) : identity(decodeAttr(src));
+    return tag.replace(/\s(?:src|data-vault-src|data-download-url)="[^"]*"/g, "").replace(/^<img\b/, `<img data-img="${id}"`);
+  });
+}
+const CHIP_SPAN = /<span\b([^>]*\sdata-variable-id="[^"]*"[^>]*)>[\s\S]*?<\/span>/g;
+function normalizeChipSpans(html) {
+  if (!html.includes("data-variable-id"))
+    return html;
+  return html.replace(CHIP_SPAN, (_all, attrs) => {
+    const id = attrs.match(/\sdata-variable-id="([^"]*)"/)?.[1] ?? "";
+    const index = attrs.match(/\sdata-(?:loop|variable)-index="([^"]*)"/)?.[1] ?? "";
+    return `<var:${id}:${index}>`;
+  });
+}
+function normalizeAttrs(attrs, identity, chipSpans = true) {
+  if (!attrs)
+    return void 0;
+  const out = {};
+  for (const key of Object.keys(attrs).sort()) {
+    if (key === "genHash" || key === "uid")
+      continue;
+    const value = attrs[key];
+    if (key === "src" && typeof value === "string") {
+      out[key] = identity(value);
+    } else {
+      out[key] = typeof value === "string" ? chipSpans ? normalizeChipSpans(normalizeImgTags(value, identity)) : normalizeImgTags(value, identity) : value;
+    }
+  }
+  return out;
+}
+function normalize(node, identity, chipSpans = true) {
+  switch (node.type) {
+    case "variableChip":
+      return ["var", node.attrs?.variableId ?? null];
+    case "topicNumber":
+      return ["topic", node.attrs?.group ?? null, !!node.attrs?.ref];
+    case "footnoteRef":
+      return ["note", node.attrs?.text ?? "", node.attrs?.size ?? null];
+    case "text":
+      return ["text", node.text ?? "", (node.marks ?? []).map((mark) => [mark.type, normalizeAttrs(mark.attrs, identity, chipSpans)])];
+  }
+  return [node.type, normalizeAttrs(node.attrs, identity, chipSpans), (node.content ?? []).map((child) => normalize(child, identity, chipSpans))];
+}
+function fnv1a(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function minutaBlockFingerprint(blockJson, identity = (src) => src) {
+  const body = JSON.stringify((blockJson.content ?? []).map((child) => normalize(child, identity)));
+  return `${fnv1a(body)}${body.length.toString(16)}`;
+}
+function minutaBlockFingerprintV1(blockJson, identity = (src) => src) {
+  const body = JSON.stringify((blockJson.content ?? []).map((child) => normalize(child, identity, false)));
+  return `${fnv1a(body)}${body.length.toString(16)}`;
+}
+
+function readChecklist(doc) {
+  const stored = doc.attrs.checklist;
+  return stored ?? { wanted: [...docBlocks(doc).keys()], pending: [] };
+}
+const defaultImageIdentity = (src) => src;
+function blockHash(node, identity = defaultImageIdentity) {
+  return minutaBlockFingerprint(node.toJSON(), identity);
+}
+function isBlockUntouched(node, identity = defaultImageIdentity) {
+  const genHash = node.attrs.genHash;
+  if (!genHash)
+    return false;
+  return genHash === blockHash(node, identity) || genHash === minutaBlockFingerprintV1(node.toJSON(), identity);
+}
+function docBlocks(doc) {
+  const map = /* @__PURE__ */ new Map();
+  doc.forEach((node, offset) => {
+    const id = node.attrs.blockId;
+    if (node.type.name === "minutaBlock" && id && !map.has(id))
+      map.set(id, { pos: offset, node });
+  });
+  return map;
+}
+function parseGeneratedBlocks(schema, html, identity = defaultImageIdentity) {
+  const wrapper = document.createElement("div");
+  wrapper.innerHTML = html;
+  const doc = DOMParser.fromSchema(schema).parse(wrapper);
+  const blocks = [];
+  doc.forEach((node) => {
+    if (node.type.name === "minutaBlock" && node.attrs.blockId)
+      blocks.push(node.type.create({ ...node.attrs, genHash: blockHash(node, identity) }, node.content, node.marks));
+  });
+  return blocks;
+}
+function stampGeneratedBlocks(editor, identity = defaultImageIdentity) {
+  const tr = editor.state.tr;
+  let stamped = 0;
+  editor.state.doc.forEach((node, offset) => {
+    if (node.type.name !== "minutaBlock")
+      return;
+    const genHash = blockHash(node, identity);
+    if (node.attrs.genHash !== genHash) {
+      tr.setNodeMarkup(offset, void 0, { ...node.attrs, genHash });
+      stamped++;
+    }
+  });
+  if (tr.docChanged)
+    editor.view.dispatch(tr);
+  return stamped;
+}
+function baseChipKey(variableId, parentBlockId) {
+  return `${parentBlockId ?? ""}|${variableId ?? ""}`;
+}
+function chipKey(variableId, parentBlockId, loopIndex) {
+  return `${baseChipKey(variableId, parentBlockId)}|${loopIndex ?? ""}`;
+}
+function collectChips(html) {
+  const wrapper = document.createElement("div");
+  wrapper.innerHTML = html;
+  const byKey = /* @__PURE__ */ new Map();
+  const byBase = /* @__PURE__ */ new Map();
+  wrapper.querySelectorAll("span[data-variable-id]").forEach((el) => {
+    const variableId = el.getAttribute("data-variable-id");
+    const parentBlockId = el.getAttribute("data-parent-block-id");
+    const loopIndex = el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index");
+    const value = { html: el.outerHTML, text: el.textContent ?? "", loopIndex };
+    for (const [map, key] of [[byKey, chipKey(variableId, parentBlockId, loopIndex)], [byBase, baseChipKey(variableId, parentBlockId)]]) {
+      const list = map.get(key) ?? [];
+      list.push(value);
+      map.set(key, list);
+    }
+  });
+  return { byKey, byBase };
+}
+function matchByValue(docChips, generated) {
+  const pairs = [];
+  const count = (list, text) => list.filter((t) => t === text).length;
+  const docTexts = docChips.map((chip) => chip.node.attrs.text);
+  const genTexts = generated.map((value) => value.text);
+  const freeDoc = new Set(docChips.keys());
+  const freeGen = new Set(generated.keys());
+  docChips.forEach((chip, i) => {
+    const text = docTexts[i];
+    if (count(docTexts, text) !== 1 || count(genTexts, text) !== 1)
+      return;
+    const j = genTexts.indexOf(text);
+    pairs.push({ ...chip, next: generated[j] });
+    freeDoc.delete(i);
+    freeGen.delete(j);
+  });
+  if (freeDoc.size === 1 && freeGen.size === 1) {
+    const [i] = freeDoc;
+    const [j] = freeGen;
+    pairs.push({ ...docChips[i], next: generated[j] });
+  }
+  return pairs;
+}
+function refreshChips(tr, chips) {
+  const inDoc = /* @__PURE__ */ new Map();
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name !== "variableChip")
+      return;
+    const key = chipKey(node.attrs.variableId, node.attrs.parentBlockId, node.attrs.loopIndex);
+    const list = inDoc.get(key) ?? [];
+    list.push({ pos, node });
+    inDoc.set(key, list);
+  });
+  let changed = 0;
+  for (const [key, docChips] of inDoc) {
+    let generated = chips.byKey.get(key);
+    if (!generated?.length && docChips[0].node.attrs.loopIndex == null) {
+      const { variableId, parentBlockId } = docChips[0].node.attrs;
+      generated = chips.byBase.get(baseChipKey(variableId, parentBlockId));
+    }
+    if (!generated?.length)
+      continue;
+    const values = generated;
+    const uniform = values.every((value) => value.html === values[0].html);
+    const pairs = uniform ? docChips.map((chip) => ({ ...chip, next: values[0] })) : matchByValue(docChips, values);
+    for (const { pos, node, next } of pairs) {
+      const loopIndex = uniform ? node.attrs.loopIndex : next.loopIndex ?? node.attrs.loopIndex;
+      if (next.html === node.attrs.html && loopIndex === node.attrs.loopIndex)
+        continue;
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, html: next.html, text: next.text, loopIndex });
+      if (next.text !== node.attrs.text)
+        changed++;
+    }
+  }
+  return changed;
+}
+function refreshIslandChips(tr, chips) {
+  let changed = 0;
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name !== "htmlIsland" || !String(node.attrs.html ?? "").includes("data-variable-id"))
+      return;
+    const tpl = document.createElement("template");
+    tpl.innerHTML = node.attrs.html;
+    let touched = false;
+    tpl.content.querySelectorAll("span[data-variable-id]").forEach((el) => {
+      const key = chipKey(
+        el.getAttribute("data-variable-id"),
+        el.getAttribute("data-parent-block-id"),
+        el.getAttribute("data-loop-index") ?? el.getAttribute("data-variable-index")
+      );
+      const values = chips.byKey.get(key);
+      if (!values?.length || values.some((value) => value.html !== values[0].html))
+        return;
+      if (el.outerHTML !== values[0].html) {
+        if (el.textContent !== values[0].text)
+          changed++;
+        el.outerHTML = values[0].html;
+        touched = true;
+      }
+    });
+    if (touched)
+      tr.setNodeMarkup(pos, void 0, { ...node.attrs, html: tpl.innerHTML });
+    return false;
+  });
+  return changed;
+}
+function insertPos(doc, blockId, order) {
+  const present = docBlocks(doc);
+  const index = order.indexOf(blockId);
+  for (let i = index - 1; i >= 0; i--) {
+    const prev = present.get(order[i]);
+    if (prev)
+      return prev.pos + prev.node.nodeSize;
+  }
+  return 0;
+}
+function listConflicts(doc) {
+  return readChecklist(doc).pending.map(({ blockId, kind, title }) => ({ blockId, blockTitle: title, kind }));
+}
+function applyChecklistToDocument(editor, generatedHtml, options = {}) {
+  const identity = options.imageIdentity ?? defaultImageIdentity;
+  const generated = parseGeneratedBlocks(editor.schema, generatedHtml, identity);
+  const genById = new Map(generated.map((node) => [node.attrs.blockId, node]));
+  const order = generated.map((node) => node.attrs.blockId);
+  const wanted = new Set(order);
+  const stored = readChecklist(editor.state.doc);
+  const before = new Set(stored.wanted);
+  const previousPending = new Map(stored.pending.map((entry) => [entry.blockId, entry]));
+  const pending = /* @__PURE__ */ new Map();
+  const toggled = options.toggled;
+  const tr = editor.state.tr;
+  const result = {
+    inserted: [],
+    removed: [],
+    regenerated: [],
+    variablesUpdated: 0,
+    conflicts: [],
+    toggledWithoutContent: false,
+    lastBlockKept: false
+  };
+  const setConflict = (id, kind, node, title) => {
+    pending.set(id, { blockId: id, kind, title, node: node ? node.toJSON() : null });
+  };
+  const ids = [...order, ...[...docBlocks(tr.doc).keys()].filter((id) => !wanted.has(id))];
+  if (toggled && !ids.includes(toggled.blockId))
+    ids.push(toggled.blockId);
+  for (const id of ids) {
+    const fresh = genById.get(id) ?? null;
+    const explicit = toggled?.blockId === id;
+    const turnedOn = explicit ? toggled.show : !before.has(id) && !!fresh;
+    const turnedOff = explicit ? !toggled.show : before.has(id) && !fresh;
+    const present = docBlocks(tr.doc).get(id);
+    if (!present) {
+      if (turnedOn && fresh) {
+        tr.insert(insertPos(tr.doc, id, order), fresh);
+        result.inserted.push(id);
+      } else if (explicit && toggled.show && !fresh) {
+        result.toggledWithoutContent = true;
+      }
+      continue;
+    }
+    const untouched = isBlockUntouched(present.node, identity);
+    const title = present.node.attrs.blockTitle ?? null;
+    if (!fresh || turnedOff) {
+      if (!turnedOff) {
+        const open = previousPending.get(id);
+        if (!untouched && open?.kind === "remove")
+          pending.set(id, open);
+        continue;
+      }
+      if (tr.doc.childCount <= 1) {
+        result.lastBlockKept = true;
+        continue;
+      }
+      if (untouched) {
+        tr.delete(present.pos, present.pos + present.node.nodeSize);
+        result.removed.push(id);
+      } else {
+        setConflict(id, "remove", null, title);
+      }
+      continue;
+    }
+    if (fresh.attrs.genHash === present.node.attrs.genHash)
+      continue;
+    if (untouched) {
+      tr.replaceWith(present.pos, present.pos + present.node.nodeSize, fresh);
+      result.regenerated.push(id);
+    } else {
+      setConflict(id, "replace", fresh, title);
+    }
+  }
+  const chips = collectChips(generatedHtml);
+  result.variablesUpdated = refreshChips(tr, chips) + refreshIslandChips(tr, chips);
+  const next = { wanted: [...wanted], pending: [...pending.values()] };
+  if (JSON.stringify(next) !== JSON.stringify(stored) || tr.docChanged)
+    tr.setDocAttribute("checklist", next);
+  if (tr.docChanged) {
+    editor.view.dispatch(closeHistory(tr));
+  }
+  result.conflicts = next.pending.map(({ blockId, kind, title }) => ({ blockId, blockTitle: title, kind }));
+  return result;
+}
+function resolveChecklistConflict(editor, blockId, resolution) {
+  const stored = readChecklist(editor.state.doc);
+  const entry = stored.pending.find((item) => item.blockId === blockId);
+  const present = docBlocks(editor.state.doc).get(blockId);
+  const tr = editor.state.tr;
+  const rest = { ...stored, pending: stored.pending.filter((item) => item.blockId !== blockId) };
+  if (!entry || !present) {
+    if (entry) {
+      tr.setDocAttribute("checklist", rest);
+      editor.view.dispatch(tr);
+    }
+    return false;
+  }
+  if (resolution === "apply" && entry.kind === "remove" && editor.state.doc.childCount <= 1)
+    return false;
+  const fresh = entry.node ? editor.schema.nodeFromJSON(entry.node) : null;
+  if (resolution === "apply") {
+    if (entry.kind === "remove")
+      tr.delete(present.pos, present.pos + present.node.nodeSize);
+    else if (fresh)
+      tr.replaceWith(present.pos, present.pos + present.node.nodeSize, fresh);
+  } else if (entry.kind === "replace" && fresh) {
+    tr.setNodeMarkup(present.pos, void 0, { ...present.node.attrs, genHash: fresh.attrs.genHash });
+  }
+  tr.setDocAttribute("checklist", rest);
+  editor.view.dispatch(closeHistory(tr));
+  return true;
+}
+
 function h(tag, attrs = {}, children = []) {
   const el = document.createElement(tag);
   if (attrs.class)
@@ -2167,6 +2545,32 @@ function createMinutaEditor(element, opts) {
         return Promise.resolve(0);
       return refreshVaultImages(ed, resolveUrl, { meta: { [POC_ASSET_SWAP]: true } });
     },
+    applyChecklist(generatedHtml, options) {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        throw new Error("editor n\xE3o montado");
+      return applyChecklistToDocument(ed, generatedHtml, options ?? {});
+    },
+    checklistConflicts() {
+      const ed = tiptap;
+      return ed && !ed.isDestroyed ? listConflicts(ed.state.doc) : [];
+    },
+    resolveChecklistConflict(blockId, resolution) {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        return false;
+      return resolveChecklistConflict(ed, blockId, resolution);
+    },
+    stampGenerated() {
+      const ed = tiptap;
+      if (!ed || ed.isDestroyed)
+        return 0;
+      return stampGeneratedBlocks(ed);
+    },
+    documentBlockIds() {
+      const ed = tiptap;
+      return ed && !ed.isDestroyed ? [...docBlocks(ed.state.doc).keys()] : [];
+    },
     schedulePaginate,
     refreshChrome,
     totalPages: () => totalPages,
@@ -2186,4 +2590,4 @@ function createMinutaEditor(element, opts) {
   return api;
 }
 
-export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, PAGINATE_META, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPaginationPlugin, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, breaksEqual, buildPocExtensions, collectVaultRefs, computePocBreaks, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteSizePt, formatTopicNumber, iconSvg, pocPageKey, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, swapVaultSrc, variableChipHtml, vaultImageHtml, vaultRefOf };
+export { A4_HEIGHT_PX, A4_WIDTH_PX, DEFAULT_MARGINS, DOC_FONTS, ICON_PATHS, PAGINATE_META, POC_ASSET_SWAP, PocDocument, PocFootnoteRef, PocHtmlIsland, PocInlineStyle, PocMinutaBlock, PocMissingImage, PocPaginationPlugin, PocStylePassthrough, PocStyledDiv, PocTemplateVariable, PocTopicNumber, PocTopicRenumber, PocUnderline, PocVariableChip, TOPIC_DEFAULT_GROUP, TOPIC_GROUP_ATTR, TOPIC_NUMBER_ATTR, TOPIC_REF_ATTR, TOPIC_ROMAN_ATTR, blockHash, breaksEqual, buildPocExtensions, collectVaultRefs, computePocBreaks, createMinutaEditor, decodeVaultAttr, dispatchVariableClick, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteSizePt, formatTopicNumber, iconSvg, isBlockUntouched, minutaBlockFingerprint, pocPageKey, readTopicNumber, refreshVaultImages, renewVaultImageTags, renumberPocFootnotes, renumberPocTopics, renumberPocTopicsIn, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, swapVaultSrc, variableChipHtml, vaultImageHtml, vaultRefOf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/minuta-editor",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Editor de minuta do defesa.ai sem framework: folha A4 paginada, edição rica, placeholders de variável e export DOCX fiel ao preview — monta em qualquer app (React, Vue, vanilla)",
   "repository": {
     "type": "git",