@meistrari/minuta-editor 1.0.0

package/dist/docx.d.mts

@@ -0,0 +1,5 @@
+export { a as PocDocxChrome, b as PocDocxExportOptions, u as pocExportDocx } from './shared/minuta-editor.e223a421.mjs';
+import '@tiptap/core';
+import '@tiptap/pm/model';
+import '@tiptap/pm/view';
+import '@tiptap/pm/state';

package/dist/docx.d.ts

@@ -0,0 +1,5 @@
+export { a as PocDocxChrome, b as PocDocxExportOptions, u as pocExportDocx } from './shared/minuta-editor.e223a421.js';
+import '@tiptap/core';
+import '@tiptap/pm/model';
+import '@tiptap/pm/view';
+import '@tiptap/pm/state';

package/dist/docx.mjs

@@ -0,0 +1,5 @@
+export { pocExportDocx } from './chunks/docxExport.mjs';
+import './shared/minuta-editor.b2512170.mjs';
+import '@tiptap/pm/state';
+import '@tiptap/pm/view';
+import 'docx';

package/dist/index.d.mts

@@ -0,0 +1,413 @@
+/// <reference types="@tiptap/extension-bold" />
+/// <reference types="@tiptap/extension-blockquote" />
+/// <reference types="@tiptap/extension-bullet-list" />
+/// <reference types="@tiptap/extension-code" />
+/// <reference types="@tiptap/extension-code-block" />
+/// <reference types="@tiptap/extension-dropcursor" />
+/// <reference types="@tiptap/extension-gapcursor" />
+/// <reference types="@tiptap/extension-hard-break" />
+/// <reference types="@tiptap/extension-heading" />
+/// <reference types="@tiptap/extension-history" />
+/// <reference types="@tiptap/extension-horizontal-rule" />
+/// <reference types="@tiptap/extension-italic" />
+/// <reference types="@tiptap/extension-list-item" />
+/// <reference types="@tiptap/extension-ordered-list" />
+/// <reference types="@tiptap/extension-paragraph" />
+/// <reference types="@tiptap/extension-strike" />
+/// <reference types="@tiptap/extension-text" />
+/// <reference types="@tiptap/extension-table" />
+/// <reference types="@tiptap/extension-bubble-menu" />
+import { Node, Editor, Mark, Extension } from '@tiptap/core';
+import { EditorView } from '@tiptap/pm/view';
+import { P as PocPageConfig } from './shared/minuta-editor.e223a421.mjs';
+export { e as PAGINATE_META, a as PocDocxChrome, b as PocDocxExportOptions, q as PocLoneRow, d as PocPageBreak, c as PocPageNote, t as PocPaginationPlugin, s as breaksEqual, h as buildPocFooterEl, g as buildPocHeaderEl, j as buildPocNotesEl, k as computePocBreaks, r as computePocLoneRows, i as isPocChromeCanvas, l as isPocFlexRow, f as pocChromeFlowHeight, o as pocLoneCellIndex, m as pocNodeHasVisibleContent, n as pocNodePaintsBox, p as pocPageKey } from './shared/minuta-editor.e223a421.mjs';
+import '@tiptap/pm/model';
+import '@tiptap/pm/state';
+
+/**
+ * Variáveis de template da minuta — o formato do placeholder e a resolução dele.
+ *
+ * O template é um documento normal do editor; onde entra um valor há um NÓ
+ * atômico (`templateVariable`, ver editorExtensions), serializado como
+ * `<span data-minuta-var="CHAVE" data-minuta-var-label="Rótulo">Rótulo</span>`.
+ *
+ * Por que nó e não `#CHAVE` no texto: no editor rico o texto é fatiado em
+ * marks. Negritar metade de um `#PROCESSO` produz
+ * `<b>#PRO</b>CESSO`, e qualquer substituição textual passa reto — em silêncio,
+ * só naquele template, só naquela linha. Como nó atômico o placeholder não tem
+ * "metade": seleciona inteiro, apaga inteiro, formata inteiro.
+ *
+ * ATENÇÃO: este arquivo é DUPLICADO em
+ * `packages/server/src/standalone-minuta/template-variables.ts` — o servidor
+ * resolve na criação da minuta e não pode importar o pacote publicado no npm.
+ * Mudou aqui, muda lá (e vice-versa); há teste de paridade no server.
+ */
+/** Definição de uma variável disponível — vem do app hospedeiro, não do CDB. */
+type MinutaVariableDef = {
+    /** chave usada no documento e nos valores (ex.: `PROCESSO`) */
+    key: string;
+    /** rótulo exibido no chip e no seletor (ex.: `Nº do Processo`) */
+    label: string;
+    /** de onde o valor sai — vira o tooltip do chip */
+    description?: string;
+    /** agrupador opcional no seletor (ex.: `Processo`, `Réu`) */
+    group?: string;
+};
+declare function escapeHtml(value: string): string;
+/**
+ * Chaves das variáveis usadas no documento, na ordem em que aparecem e sem
+ * repetição. É o que substitui o `extractPeticaoVariaveisFromTexto` de quem
+ * hospeda: o host guarda esta lista junto com o template e não precisa ler HTML.
+ */
+declare function extractTemplateVariables(html: string | null | undefined): string[];
+/**
+ * Troca os placeholders pelos valores. O que NÃO tem valor continua sendo um
+ * placeholder vivo no documento — não vira texto vazio nem some.
+ *
+ * É de propósito: uma variável sem valor é um buraco na peça, e o lugar de
+ * mostrar isso é o próprio parágrafo em que ela está, não um botão desabilitado
+ * no rodapé do modal. Como o nó sobrevive, `extractTemplateVariables` na minuta
+ * gerada responde "o que ainda falta", e mandar os valores de novo resolve.
+ */
+declare function resolveTemplateVariables(html: string | null | undefined, values: Record<string, string | null | undefined> | null | undefined): {
+    html: string;
+    missing: string[];
+};
+
+/**
+ * Extensões Tiptap da PoC do editor de minuta.
+ *
+ * Modelo: doc → minutaBlock+ → (paragraph | heading | styledDiv | htmlIsland | ...)
+ * - minutaBlock: wrapper com proveniência (blockId/título do bloco do template)
+ * - htmlIsland: tabelas/listas/imagens/svg preservados como ilhas não-editáveis (HTML cru)
+ * - variableChip: <span data-variable-id> vira nó atômico — a variável continua "viva"
+ * - templateVariable: <span data-minuta-var> — placeholder NÃO resolvido do template
+ * - inlineStyle/styledDiv/passthrough: preservam o CSS inline do pipeline de render
+ */
+/**
+ * Meta de transação: troca de imagem fria pelo blob recém-baixado (load
+ * progressivo). Não é edição do advogado — fica fora do undo e não pode
+ * marcar o documento como sujo (senão o autosave dispara sozinho no load).
+ */
+declare const POC_ASSET_SWAP = "pocAssetSwap";
+declare const PocDocument: Node<any, any>;
+declare const PocMinutaBlock: Node<any, any>;
+declare const PocHtmlIsland: Node<any, any>;
+/**
+ * Aviso de imagem faltando — a caixa tracejada que o render emite quando a
+ * variável de imagem não foi preenchida.
+ *
+ * Antes ela chegava aqui como um `styledDiv` comum: apagar exigia selecionar o
+ * texto por dentro, e a moldura sobrava no documento. Como nó próprio ela é
+ * atômica e selecionável (um clique + Backspace resolve), ganha um botão de
+ * remover e um alvo de clique para escolher a imagem ali mesmo.
+ *
+ * Na etapa de edição o DOCUMENTO é a verdade — o checklist fica travado —, então
+ * escolher a imagem insere no texto editado; não mexe na variável do caso.
+ *
+ * O nó guarda só o ID da variável e REDESENHA a caixa a partir dele. Guardar o
+ * `outerHTML` e devolvê-lo a um `innerHTML` faria do corpo da edição — que é
+ * dado persistido, editável por qualquer um do workspace — um vetor de stored
+ * XSS: bastaria uma `div.missing-image-warning` forjada com `onerror` para
+ * rodar script no editor de quem abrisse o caso depois.
+ */
+declare const PocMissingImage: Node<any, any>;
+declare const PocVariableChip: Node<any, any>;
+/** `<span data-variable-id>` com o texto trocado — o que `setVariableValue` grava no chip */
+declare function variableChipHtml(currentHtml: string, text: string): string;
+/**
+ * Placeholder de variável do TEMPLATE — o `#NOME_VARIAVEL` de antigamente, só
+ * que como nó atômico em vez de texto (ver `utils/templateVariables.ts` para o
+ * porquê e para o formato).
+ *
+ * O catálogo (`options.catalog`) vem do app hospedeiro: o CDB não sabe o que é
+ * `SIGLA_FORO`, só sabe que existe um lugar no documento com esse nome. O nó
+ * guarda o rótulo junto (para um template abrir legível sem catálogo, ex.: no
+ * histórico), mas quem manda na exibição é o catálogo — renomear uma variável
+ * no host reflete em todo template já salvo, sem migrar documento nenhum.
+ *
+ * Sobrevive à geração: `resolveTemplateVariables` só troca o que tem valor, e o
+ * que sobra continua sendo este nó — um buraco visível no parágrafo em que ele
+ * está, e não um erro genérico no rodapé de um modal.
+ */
+/** o catálogo pode chegar depois do mount (host que carrega async) — daí o getter */
+type MinutaVariableCatalog = MinutaVariableDef[] | (() => MinutaVariableDef[]);
+declare const PocTemplateVariable: Node<{
+    catalog: MinutaVariableCatalog;
+}, any>;
+/**
+ * Nota de rodapé: o render devolve `<sup data-footnote="texto">n</sup>` e o
+ * export transforma em nota de rodapé DE VERDADE no Word (o pipeline legado faz
+ * o mesmo via footnotes_filter.lua do conversor). Precisa ser um nó do schema —
+ * senão o Tiptap descarta o data-footnote no round-trip e o texto da nota some.
+ */
+declare const PocFootnoteRef: Node<any, any>;
+/** re-sequencia a numeração das chamadas de nota na ordem do documento */
+declare function renumberPocFootnotes(editor: Editor): void;
+declare const PocStyledDiv: Node<any, any>;
+declare const PocInlineStyle: Mark<any, any>;
+declare const PocUnderline: Mark<any, any>;
+/** Preserva style/class inline nos blocos de texto (o pipeline de render inlina todo o CSS). */
+declare const PocStylePassthrough: Extension<any, any>;
+declare function buildPocExtensions(pageConfig?: PocPageConfig, options?: {
+    /** catálogo de variáveis do host — habilita os chips do modo template */
+    variables?: MinutaVariableCatalog;
+    /**
+     * Primeiro a ver o teclado, ANTES do keymap do editor. Devolver `true`
+     * consome a tecla.
+     *
+     * Existe porque `editorProps.handleKeyDown` não serve: o `someProp` do
+     * ProseMirror percorre os plugins antes das props diretas, então o keymap
+     * do StarterKit trata o Enter (quebra o parágrafo) e o handler da view
+     * nunca roda. Quem precisa de um popover dirigido pelo teclado com o foco
+     * ainda no editor — o seletor de variável — depende disso.
+     */
+    handleKeyDown?: (view: EditorView, event: KeyboardEvent) => boolean;
+}): (Node<any, any> | Mark<any, any> | Extension<any, any>)[];
+
+/**
+ * O editor de minuta como coisa montável em qualquer lugar: `createMinutaEditor(el, opts)`.
+ *
+ * Port do `MinutaDocxEditor.vue` para DOM cru, comportamento a comportamento.
+ * O que era `ref`/`computed`/`watch` virou estado local + funções `render*`
+ * chamadas nos mesmos momentos; o que era `<template>` virou `h()`. As
+ * decisões que o componente Vue tomou — rAF para paginar, zoom por CSS,
+ * placeholder como nó atômico, foco do seletor — estão preservadas, com os
+ * comentários originais onde eles explicavam o porquê.
+ *
+ * Zero I/O: nada de fetch, autosave ou histórico. Isso é do host.
+ */
+declare const A4_WIDTH_PX = 794;
+declare const A4_HEIGHT_PX = 1123;
+/** 2,5cm topo/rodapé, 3cm laterais, em px @96dpi */
+declare const DEFAULT_MARGINS: MinutaMargins;
+interface MinutaMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface MinutaHeader {
+    logoUrl: string | null;
+    position: 'left' | 'center' | 'right';
+}
+interface MinutaChromeText {
+    header: string;
+    footer: string;
+    headerScope?: 'all' | 'first';
+    footerScope?: 'all' | 'first';
+    showPageNumber?: boolean;
+}
+/** uma variável do case dentro do documento (`<span data-variable-id>`) */
+interface MinutaVariableRef {
+    variableId: string;
+    parentBlockId: string | null;
+    /** texto atual do trecho */
+    text: string;
+}
+interface MinutaEditorOptions {
+    /** documento inicial (HTML) */
+    html: string;
+    editable?: boolean;
+    margins?: MinutaMargins;
+    header?: MinutaHeader;
+    /** cabeçalho/rodapé em HTML (texto ou canvas) */
+    chrome?: Partial<MinutaChromeText>;
+    /**
+     * Catálogo de variáveis do host. Com ele o editor vira editor de TEMPLATE:
+     * `/` e o botão da toolbar inserem placeholders. Aceita getter para o
+     * catálogo que chega depois do mount.
+     */
+    variables?: MinutaVariableCatalog;
+    /**
+     * Upload da imagem inserida pela toolbar. Quando presente, a tag entra com
+     * src presignado + data-vault-src durável; sem ele (ou em falha), a imagem
+     * vira data-URI embutida no documento.
+     */
+    uploadImage?: ((file: File) => Promise<{
+        src: string;
+        vaultSrc: string;
+    } | null>) | null;
+    /** barra de formatação (default: true). `false` = o host monta a dele sobre `tiptap` */
+    toolbar?: boolean;
+    /** realce de proveniência de bloco no hover (só faz sentido no modo estruturado) */
+    showBlockOrigin?: boolean;
+    onReady?: (tiptap: Editor) => void;
+    /** o documento mudou por edição (troca de imagem fria não conta) */
+    onChange?: () => void;
+    /**
+     * Qualquer transação, inclusive só de seleção. É o que uma toolbar montada
+     * pelo host precisa para `tiptap.isActive('bold')` acompanhar o cursor —
+     * `onChange` não dispara quando só a seleção anda.
+     */
+    onTransaction?: () => void;
+    /** read-only: clique num bloco com proveniência */
+    onBlockClick?: (blockId: string) => void;
+    /** clique no cabeçalho/rodapé da folha (além do CustomEvent `poc:edit-chrome`) */
+    onEditChrome?: (part: 'header' | 'footer') => void;
+    /**
+     * Clique numa variável renderizada (`<span data-variable-id>` do documento).
+     * É a ponte documento → formulário: o host recebe o id e foca o campo.
+     */
+    onVariableClick?: (variable: MinutaVariableRef) => void;
+    onError?: (message: string) => void;
+}
+interface MinutaEditor {
+    /** a instância do Tiptap — escotilha de fuga para o que a API não cobre */
+    readonly tiptap: Editor | null;
+    /** `.poc-editor-root` */
+    readonly root: HTMLElement;
+    /** container com scroll (o host ancora coisas nele, ex.: gutter de anotações) */
+    readonly container: HTMLElement;
+    /** a folha A4 — host para overlays posicionados no documento */
+    readonly sheet: HTMLElement;
+    getHTML: () => string;
+    /** `Blob` do .docx com as mesmas quebras do preview. Carrega a lib sob demanda. */
+    exportDocx: () => Promise<Blob>;
+    /** chaves de variável usadas no documento, na ordem, sem repetição */
+    usedVariables: () => string[];
+    setEditable: (editable: boolean) => void;
+    setChrome: (chrome: Partial<MinutaChromeText>) => void;
+    setHeader: (header: MinutaHeader) => void;
+    setVariables: (variables: MinutaVariableCatalog | undefined) => void;
+    /** liga/desliga a barra de formatação do pacote */
+    setToolbar: (on: boolean) => void;
+    setMargins: (margins: MinutaMargins) => void;
+    setShowBlockOrigin: (on: boolean) => void;
+    /**
+     * Ponte formulário → documento: rola até a primeira ocorrência da variável
+     * e a destaca por um instante. `false` se ela não está no documento.
+     */
+    scrollToVariable: (variableId: string) => boolean;
+    /**
+     * Troca o texto de TODAS as ocorrências da variável no documento — inclusive
+     * numa edição livre, porque a marca é um nó e sobrevive à lapidação. É o que
+     * deixa um formulário de variáveis continuar valendo depois que o advogado
+     * editou o texto em volta. Devolve quantas ocorrências mudaram.
+     */
+    setVariableValue: (variableId: string, value: string) => number;
+    /** as variáveis presentes no documento, na ordem, sem repetição */
+    variablesInDocument: () => 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 */
+    refreshChrome: () => void;
+    totalPages: () => number;
+    destroy: () => void;
+}
+declare function createMinutaEditor(element: HTMLElement, opts: MinutaEditorOptions): MinutaEditor;
+
+/**
+ * Popover de nota de rodapé, ancorado na chamada (estilo comentário do Google
+ * Docs). Port 1:1 do trecho do MinutaDocxEditor.vue: B/I/U por execCommand no
+ * contenteditable, fonte/tamanho/cor por span no trecho selecionado, Enter
+ * salva, Esc cancela, e cancelar uma nota recém-criada (ainda vazia) remove a
+ * chamada.
+ */
+/** mesmas fontes do canvas de cabeçalho/rodapé — o export lê a fonte por run */
+declare const DOC_FONTS: string[];
+
+/**
+ * Ícones da toolbar: os mesmos do Phosphor (peso regular) que o defesa.ai usa,
+ * como path SVG puro — o pacote não depende de framework nem do @phosphor-icons/vue.
+ * Extraídos de @phosphor-icons/vue 2.2.1; viewBox 0 0 256 256.
+ */
+declare const ICON_PATHS: Record<string, string>;
+declare function iconSvg(name: string, size?: number): string;
+
+/**
+ * Conteúdo de nota de rodapé: o template escreve HTML dentro de `<footnote>`
+ * (negrito, itálico, links) e declara o corpo da nota em `style="font-size: 9pt"`.
+ * O marcador do preview carrega esse conteúdo num atributo, então ele precisa
+ * de um subconjunto seguro — atributo nenhum sobrevive, só as tags de ênfase.
+ */
+/** HTML da nota reduzido a ênfase inline + links (o resto vira texto) */
+declare function sanitizeFootnoteHtml(html: string): string;
+interface FootnoteRun {
+    text: string;
+    bold?: boolean;
+    italics?: boolean;
+    underline?: boolean;
+    break?: boolean;
+    /** quando presente, o run vira ExternalHyperlink no .docx */
+    href?: string;
+    /** personalização por trecho (spans do popover) */
+    font?: string;
+    sizePt?: number;
+    /** hex SEM '#' (formato do docx) */
+    color?: string;
+}
+/** o mesmo HTML fatiado em runs — é assim que o .docx representa ênfase */
+declare function footnoteHtmlToRuns(html: string): FootnoteRun[];
+/** tamanho declarado na nota (`font-size: 9pt`) em pontos */
+declare function footnoteSizePt(style: string | null | undefined): number | null;
+
+/**
+ * Regra de *keep-with-next* do motor de paginação: um título não pode ficar
+ * órfão no pé da página, então a quebra sobe para antes dele.
+ *
+ * Vive separada de usePocPaginationPlugin porque o laço que a usa tem
+ * RETROCESSO — ele volta o índice para reavaliar o item depois de mover a
+ * quebra — e uma decisão que não avança trava o laço para sempre. Sendo pura,
+ * a regra pode ser testada sem DOM nem ProseMirror.
+ */
+interface PocKeepWithNextItem {
+    /** topo do item no fluxo normalizado (sem chrome), em px */
+    top: number;
+    /** altura do item em px */
+    height: number;
+    /** margem superior, que conta como parte da página que o item abre */
+    marginTop: number;
+    /** é um título (h1–h4)? */
+    heading: boolean;
+    /** é o parágrafo-marcador de quebra manual do template? */
+    marker: boolean;
+}
+/**
+ * A quebra deve subir do item para o título imediatamente anterior?
+ *
+ * Duas condições, e as duas são necessárias para o laço TERMINAR:
+ *
+ * 1. o título ainda não abre a página corrente — comparado pelo topo COM
+ *    MARGEM, que é exatamente o valor que vira o novo `pageStart`. Comparar
+ *    `prev.top` puro faz um título com `margin-top > 0` satisfazer a condição
+ *    para sempre: `pageStart` vira `prev.top - prev.marginTop`, que é sempre
+ *    menor que `prev.top`, e a mesma quebra é reemitida em loop;
+ *
+ * 2. o par título+item precisa CABER na página nova. Se o item sozinho já
+ *    estoura a página (uma tabela ou imagem grande vinda de DOCX), descer o
+ *    título não resolve — a quebra não avança e o laço volta ao mesmo ponto.
+ */
+declare function shouldMoveBreakToHeading(params: {
+    heading: PocKeepWithNextItem | undefined;
+    item: PocKeepWithNextItem;
+    /** topo da página corrente no fluxo normalizado */
+    pageStart: number;
+    /** altura útil disponível, já descontadas as notas de rodapé */
+    capacity: number;
+}): boolean;
+
+/**
+ * Sanitização do HTML rico de cabeçalho/rodapé (chrome) — conteúdo criado em
+ * contenteditable e PERSISTIDO (template.headers, case_edition.chrome). Sem
+ * isso, um usuário do workspace poderia armazenar markup executável que roda
+ * no browser de quem abrir o caso/preview (stored XSS).
+ *
+ * Aplicar em TODO sink (v-html / innerHTML) e ao persistir. Mantém a
+ * formatação suportada (b/i/u, spans com estilo, imagens data:/blob:/https).
+ */
+declare function sanitizeRichHtml(html: string | null | undefined): string;
+
+/**
+ * A tag de imagem que o editor insere após o upload: guarda o `src` presignado
+ * (funciona agora) E o `data-vault-src` durável (`vault://…`). Quem re-resolve
+ * os presignados expirados é o host (no embed, `refreshVaultImages`); o editor
+ * só sabe escrever a tag.
+ */
+/** mesmo escape do lazy-vault-images pro valor do atributo */
+declare function escapeVaultAttr(value: string): string;
+declare function decodeVaultAttr(value: string): string;
+declare function vaultImageHtml(src: string, vaultUrl: 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, PocUnderline, PocVariableChip, buildPocExtensions, createMinutaEditor, decodeVaultAttr, escapeHtml, escapeVaultAttr, extractTemplateVariables, footnoteHtmlToRuns, footnoteSizePt, iconSvg, renumberPocFootnotes, resolveTemplateVariables, sanitizeFootnoteHtml, sanitizeRichHtml, shouldMoveBreakToHeading, variableChipHtml, vaultImageHtml };
+export type { FootnoteRun, MinutaChromeText, MinutaEditor, MinutaEditorOptions, MinutaHeader, MinutaMargins, MinutaVariableCatalog, MinutaVariableDef, MinutaVariableRef, PocKeepWithNextItem };