/* global React, window */
const { useState, useEffect } = React;
// CATALOG is loaded from catalog.js (global)
// ================================================================
// STEP CURADORIA INTRO, capa hero full-page com o Lex Curadoria
// Aparece antes do Step6 (Volume) abrindo a seção de literatura.
// ================================================================
function StepCuradoriaIntro() {
return (
{/* Lex, ocupa TODA a coluna esquerda, full-bleed até as bordas */}
{/* fade na borda direita pra conectar com o texto */}
{/* glow verde ambiente */}
{/* Texto à direita */}
Curadoria Literária
Hora de escolher os livros do ano.
Comigo você decide o volume por série, ajusta disponibilidade, define a faixa de preço
e recebe uma curadoria personalizada baseada nos temas e no nível dos seus alunos, com ajuste fino livro a livro.
Dica do Lex: você pode voltar atrás a qualquer momento.
{/* ===== FAIXA INFERIOR: 4 etapas em horizontal ===== */}
Os 5 passos da Curadoria
{[
{ n: "01", t: "Volume", d: "Livros por série, por idioma" },
{ n: "02", t: "Disponibilidade", d: "Filtros de estoque e prazo" },
{ n: "03", t: "Preços", d: "Faixa alvo por aluno / ano" },
{ n: "04", t: "Recomendação", d: "Curadoria série a série" },
{ n: "05", t: "Detalhes", d: "Ajuste fino livro a livro" },
].map(s => (
{stageSeries.map(renderSeriesRow)}
);
};
// ===== Exportar Excel =====
const exportExcel = (scope) => {
if (!window.XLSX) { alert("Biblioteca de exportação ainda carregando..."); return; }
const XLSX = window.XLSX;
const wb = XLSX.utils.book_new();
const SCOPE_LABEL = { lit: "Literatura", did: "Didáticos", pap: "Papelaria", custom: "Outros", all: "Lista Completa" };
const components = scope === "all" ? ["lit","did","pap","custom"] : [scope];
components.forEach(comp => {
const rows = [];
// Coluna "Variação 2025→2026" removida (reunião 26/08/2026) — vinha de
// yoyPct, que é sintética/demo (ver comentário perto de useIPCA acima),
// não fazia sentido exportar uma variação fake pra escola/família.
rows.push(["Série", "Item", "Editora/Marca", "Qtde", "Preço unitário", "Total"]);
seriesData.forEach(sd => {
const items = sd[comp].items || [];
if (items.length === 0 && sd[comp].value > 0) {
// garante uma linha por série mesmo quando o item não foi resolvido no catálogo
rows.push([
sd.label,
`(${comp === "lit" ? "Literatura" : comp === "did" ? "Didáticos" : comp === "pap" ? "Papelaria" : "Outros"} estimada)`,
"",
1,
sd[comp].value,
sd[comp].value,
]);
}
items.forEach(it => {
rows.push([
sd.label,
it.name,
it.sub || "",
comp === "pap" ? (it.qty || 1) : 1,
it.price,
comp === "pap" ? (it.total || it.price) : it.price,
]);
});
});
// se a aba ficou só com header, ainda assim mantém a aba pra deixar claro
if (rows.length === 1) {
rows.push(["—", "(sem itens nesta categoria)", "", "", "", ""]);
}
const ws = XLSX.utils.aoa_to_sheet(rows);
// formata coluna preço/total como moeda
const range = XLSX.utils.decode_range(ws["!ref"]);
for (let R = 1; R <= range.e.r; R++) {
["E","F"].forEach(col => {
const cell = ws[col + (R+1)];
if (cell) cell.z = '"R$" #,##0.00';
});
}
ws["!cols"] = [{wch:14},{wch:42},{wch:22},{wch:8},{wch:14},{wch:14}];
XLSX.utils.book_append_sheet(wb, ws, SCOPE_LABEL[comp]);
});
const fname = `Lista2026_${SCOPE_LABEL[scope].replace(/\s/g,"_")}_${new Date().toISOString().slice(0,10)}.xlsx`;
XLSX.writeFile(wb, fname);
setExportOpen(false);
};
return (
{lexCopy}
{/* Hero: estimativa média por aluno (foco principal). Coluna do IPCA
removida (reunião 26/08/2026, ver comentário acima) — card ocupa a
largura toda agora. */}
Soma de literatura, didáticos e papelaria. Cada família compra a lista da sua série, com o desconto da escola no Scolados.
{/* Toolbar. Toggle "Variação em %/R$" removido junto com o resto da
variação YoY (reunião 26/08/2026) — não fazia mais sentido sem
nenhuma DeltaPill sendo exibida. */}
setGroupByStage(false)}>Por série setGroupByStage(true)}>Agrupado por etapa
{exportOpen && (
Exportar só uma categoria
{[
["lit", "📚 Só Literatura"],
["did", "📘 Só Didáticos"],
["pap", "✏️ Só Papelaria"],
["custom", "🎒 Só Outros"],
].map(([id, label]) => (
))}
{/* Rodapé com legenda de cores (caiu/subiu/novo) e "clique numa
célula..." removido (reunião 26/08/2026) — as cores eram baseadas
na variação sintética que foi tirada da tela, e o texto de dica
também saiu a pedido da Joana. */}
);
}
// Pílula de variação: mostra % ou R$ conforme showAs
function DeltaPill({ pct, novo, showAs, baseValue, small }) {
if (novo) {
return
);
}
function ToolBtn({ on, onClick, children }) {
return (
);
}
function Legend({ swatch, children }) {
return (
{children}
);
}
// Step 10: Recommendations per series (swipeable)
const SERIES_LIST = ["1º ano","2º ano","3º ano","4º ano","5º ano","6º ano","7º ano","8º ano","9º ano","1º EM","2º EM","3º EM"];
// Acha a turma (grade) real vinda da API que corresponde à posição `seriesIdx`
// da lista de séries ATIVA da escola (`seriesList`, ver resolveSeriesList em
// shared.jsx — já não é mais sempre a lista fixa de 12, pode ter Educação
// Infantil na frente, séries renomeadas, extras etc). Usado tanto no
// carrossel (Step9) quanto na revisão consolidada (Step10) e na confirmação
// final (Step11) pra achar a grade certa e persistir pin/unpin na lista.
// Casa por nome exato primeiro; se a turma real tiver um nome diferente do
// cadastrado (ex: "6º Ano B" vs "6º ano"), casa pelo padrão canônico
// embutido no nome (inferCanonicalSeriesName, shared.jsx); sem nenhum dos
// dois, cai no fallback posicional (mesmo comportamento de antes).
function findGradeForSeriesIndex(grades, seriesIdx, seriesList) {
if (!Array.isArray(grades) || grades.length === 0) return null;
const list = seriesList || SERIES_LIST;
const targetName = list[seriesIdx];
if (targetName) {
const byExactName = grades.find((grade) => grade && grade.name === targetName);
if (byExactName) return byExactName;
const targetCanonical = window.inferCanonicalSeriesName ? window.inferCanonicalSeriesName(targetName) : null;
if (targetCanonical) {
const byCanonical = grades.find((grade) => window.inferCanonicalSeriesName(grade && grade.name) === targetCanonical);
if (byCanonical) return byCanonical;
}
}
return grades[seriesIdx] || null;
}
// Depois de remover um livro de verdade no backend (unpinBookFromGrade),
// o cache local de "quais itens crus essa série tem" — data.runtimeSelection
// .recommendedByGradeId[gradeId].items — continuava com o item removido.
// Esse cache é considerado "fresco" pra sempre (hasFreshCoverCache só olha
// coverVersion, uma constante fixa, nunca expira sozinho) e é persistido
// no localStorage — então um refresh recarregava esse cache velho sem
// bater no backend de novo, e o efeito de seed (que resemeia pinned a
// partir desses itens crus) trazia o livro "deletado" de volta. O request
// de remover funcionava (o backend removia de verdade), a view atualizava
// certinho, mas o refresh sempre voltava tudo (bug reportado pelo Alex,
// 27/08/2026, depois dos fixes anteriores de remover livro). Chamar isso
// junto de toda remoção bem-sucedida mantém o cache local em sincronia
// com o que o backend realmente tem, então não sobra nada pra "ressuscitar".
function purgeFromRuntimeItemsCache(setData, gradeId, rawIdsToRemove) {
if (!gradeId || !Array.isArray(rawIdsToRemove) || rawIdsToRemove.length === 0) return;
const idSet = new Set(rawIdsToRemove);
setData(d => {
const runtimeSelection = d.runtimeSelection || {};
const byGrade = runtimeSelection.recommendedByGradeId || {};
const entry = byGrade[gradeId];
if (!entry || !Array.isArray(entry.items)) return d;
const nextItems = entry.items.filter(raw => !(raw && idSet.has(raw.id)));
if (nextItems.length === entry.items.length) return d;
return {
...d,
runtimeSelection: {
...runtimeSelection,
recommendedItems: runtimeSelection.recommendedItems === entry.items ? nextItems : runtimeSelection.recommendedItems,
recommendedByGradeId: { ...byGrade, [gradeId]: { ...entry, items: nextItems } },
},
};
});
}
// Espelho de purgeFromRuntimeItemsCache: depois de pinar um livro com
// sucesso (pinBookToGrade confirmado), o mesmo cache de itens crus da
// série (recommendedByGradeId[gradeId].items) precisa saber do livro
// novo — senão, no próximo refresh (que confia nesse cache "fresco pra
// sempre" e não busca de novo no backend), `runtimeCatalogById` não tem
// o id do livro recém-pinado, e o filtro em `pinnedForSeries`
// (`runtimeCatalogById[id]`) descarta ele silenciosamente mesmo com o id
// ainda presente em `pinned[série]` local. Bug reportado pelo Alex,
// 27/08/2026, logo depois do fix de deletar: "ao adicionar e dar refresh
// não persiste" — espelho exato do mesmo problema, na direção contrária.
function addToRuntimeItemsCache(setData, gradeId, rawItem) {
if (!gradeId || !rawItem || !rawItem.id) return;
setData(d => {
const runtimeSelection = d.runtimeSelection || {};
const byGrade = runtimeSelection.recommendedByGradeId || {};
const entry = byGrade[gradeId];
if (!entry || !Array.isArray(entry.items)) return d;
if (entry.items.some(raw => raw && raw.id === rawItem.id)) return d;
const nextItems = [...entry.items, rawItem];
return {
...d,
runtimeSelection: {
...runtimeSelection,
recommendedByGradeId: { ...byGrade, [gradeId]: { ...entry, items: nextItems } },
},
};
});
}
// Histórico de busca de Step9_Recommend: mora em data.searchHistory[série],
// mesmo padrão de data.pinned — passa pelo autosave de app.jsx
// (localStorage escopado por conta+escola + sync no backend), então
// sobrevive a refresh/logout e não fica só na sessão em memória (pedido do
// Alex, 03/09/2026: "o historico tem que manter no usuario e nao só na
// sessao"). Os livros de fato (pra runtimeCatalogById resolver o id depois
// de um refresh) já ficam garantidos por snapshotRuntimeCatalog/
// restoreRuntimeCatalog em app.jsx, que espelha window.CATALOG inteiro
// (todo resultado de busca é empurrado nele) — não precisa duplicar aqui.
const SEARCH_HISTORY_LIMIT = 20;
// Marca `ids` como "vistos agora" no histórico de busca da série: cada um
// vai pra frente da lista (mais recente primeiro), sem duplicar, com teto
// de SEARCH_HISTORY_LIMIT (os mais antigos caem fora primeiro). Serve tanto
// pro clique explícito em "ver detalhes" (um id) quanto pro resultado
// inteiro de uma busca (vários ids de uma vez) — ver previewSearchResult()
// e os efeitos de busca (texto e por tema) em Step9_Recommend.
function touchSearchHistory(setData, series, ids) {
const fresh = (Array.isArray(ids) ? ids : [ids]).filter(Boolean);
if (!fresh.length) return;
setData(d => {
const bySeries = d.searchHistory || {};
const prev = bySeries[series] || [];
const freshSet = new Set(fresh);
const rest = prev.filter((id) => !freshSet.has(id));
const next = [...fresh, ...rest].slice(0, SEARCH_HISTORY_LIMIT);
return { ...d, searchHistory: { ...bySeries, [series]: next } };
});
}
// Tira um livro do histórico de busca da série — botão de lixeira no card
// do carrossel (Step9_Recommend), pedido do Alex, 03/09/2026. Só some do
// carrossel de fato quando o livro está lá por causa do histórico
// (extraManual); um livro pinado que também esteja no histórico continua
// aparecendo (via extraPinned) — remover daqui não desfaz o pin, por
// isso o botão só é mostrado pra quem não está pinado (ver isPinnedCur na
// renderização).
function removeFromSearchHistory(setData, series, bookId) {
setData(d => {
const bySeries = d.searchHistory || {};
const prev = bySeries[series] || [];
if (!prev.includes(bookId)) return d;
return { ...d, searchHistory: { ...bySeries, [series]: prev.filter((id) => id !== bookId) } };
});
}
function Step9_Recommend() {
const { data, setData } = useApp();
const COVER_CACHE_VERSION = 3;
// Séries de verdade da escola (Passo 1), não a lista fixa de 12 — inclui
// Educação Infantil, nomes renomeados e séries extras cadastradas lá.
const activeSeries = resolveSeriesList(data);
const [series, setSeries] = useState(0); // primeira série da lista da escola
const [idx, setIdx] = useState(0);
const [query, setQuery] = useState("");
const [searchFocused, setSearchFocused] = useState(false);
const [subjectFilter, setSubjectFilter] = useState("");
// Livros achados pela busca manual, ainda não decididos (item 2, reunião
// 03/08/2026) — ver previewSearchResult() mais abaixo. Também funciona
// como histórico de busca: todo resultado que aparece numa busca (não só
// o que o usuário clica em "ver detalhes") entra aqui, pra ficar
// navegável no carrossel mesmo depois que a busca é limpada. Vem de
// data.searchHistory (ver touchSearchHistory acima) — já nasce escopado
// por série (cada série lê só a própria chave), então não precisa de
// efeito pra limpar ao trocar de aba.
const searchHistory = (data.searchHistory && data.searchHistory[series]) || [];
const hasEN = data.scolexEN !== "none";
const qtyPT = data.qtyPerYearPT ?? (data.qtyPerYear ?? 3);
const qtyEN = hasEN ? (data.qtyPerYearEN ?? 2) : 0;
const qty = qtyPT + qtyEN;
// Dados reais do Scolist (escola/turmas vindas do login)
const runtimeSelection = data.runtimeSelection || {};
const runtimeSchools = Array.isArray(runtimeSelection.availableSchools) ? runtimeSelection.availableSchools : [];
const runtimeGrades = Array.isArray(runtimeSelection.availableGrades) ? runtimeSelection.availableGrades : [];
const runtimeSchoolId = runtimeSelection.schoolId || "";
const runtimePeriod = runtimeSelection.period || String(new Date().getFullYear());
const runtimeByGrade = (runtimeSelection.recommendedByGradeId && typeof runtimeSelection.recommendedByGradeId === "object")
? runtimeSelection.recommendedByGradeId
: {};
const inflightGradesRef = React.useRef(new Set());
const [runtimeError, setRuntimeError] = useState("");
const selectedRuntimeSchool = runtimeSchools.find((s) => s.id === runtimeSchoolId) || null;
const gradeForCurrentSeries = React.useMemo(
() => findGradeForSeriesIndex(runtimeGrades, series, activeSeries),
[runtimeGrades, series, activeSeries]
);
const activeRuntimeGradeId = (gradeForCurrentSeries && gradeForCurrentSeries.id) || "";
const activeRuntimeEntry = activeRuntimeGradeId ? runtimeByGrade[activeRuntimeGradeId] : null;
const hasFreshCoverCache = (entry) => entry && Number(entry.coverVersion || 0) >= COVER_CACHE_VERSION;
const runtimeItems = Array.isArray(activeRuntimeEntry && activeRuntimeEntry.items)
? activeRuntimeEntry.items
: [];
// Primeiro uso: se login trouxe escola/período mas não trouxe turmas no contexto local,
// buscamos as grades automaticamente.
useEffect(() => {
let canceled = false;
if (!runtimeSchoolId || !runtimePeriod) return undefined;
if (runtimeGrades.length > 0) return undefined;
(async () => {
try {
const grades = await window.ScolistAPI.getSchoolGrades(runtimeSchoolId, runtimePeriod);
if (canceled) return;
setData((d) => ({
...d,
runtimeSelection: {
...(d.runtimeSelection || {}),
availableGrades: grades,
},
}));
} catch (error) {
if (!canceled) {
console.error(error);
setRuntimeError("Não foi possível carregar as turmas da escola.");
}
}
})();
return () => { canceled = true; };
}, [runtimeSchoolId, runtimePeriod, runtimeGrades.length, setData]);
const loadRuntimeRecommendationsForGrade = React.useCallback(async (grade) => {
if (!grade || !grade.id || !runtimeSchoolId || !runtimePeriod) return;
if (hasFreshCoverCache(runtimeByGrade[grade.id])) return;
if (inflightGradesRef.current.has(grade.id)) return;
inflightGradesRef.current.add(grade.id);
setRuntimeError("");
try {
const payload = await window.ScolistAPI.getRecommendedBooks({
schoolId: runtimeSchoolId,
period: runtimePeriod,
gradeId: grade.id,
});
const items = Array.isArray(payload && payload.items) ? payload.items : [];
// Série sem itens salvos no Scolist ainda não trava em erro — cai no
// estado "calibração pendente", que dispara busca por tema (efeito
// logo abaixo) quando há temas escolhidos, ou busca manual quando não.
const isCalibrationPending = items.length === 0;
setData((d) => {
const prevSelection = d.runtimeSelection || {};
const prevByGrade = (prevSelection.recommendedByGradeId && typeof prevSelection.recommendedByGradeId === "object")
? prevSelection.recommendedByGradeId
: {};
return {
...d,
schoolName: (selectedRuntimeSchool && selectedRuntimeSchool.name) || d.schoolName,
runtimeSelection: {
...prevSelection,
schoolId: runtimeSchoolId,
schoolName: (selectedRuntimeSchool && selectedRuntimeSchool.name) || prevSelection.schoolName || "",
period: String(runtimePeriod),
gradeId: grade.id,
gradeName: grade.name || grade.id,
gradeSeriesIdx: series,
listId: (payload && payload.listId) || null,
source: (payload && payload.source) || null,
recommendedItems: items,
recommendedByGradeId: {
...prevByGrade,
[grade.id]: {
items,
listId: (payload && payload.listId) || null,
source: (payload && payload.source) || null,
gradeId: grade.id,
gradeName: grade.name || grade.id,
coverVersion: COVER_CACHE_VERSION,
loadedAt: new Date().toISOString(),
isCalibrationPending,
},
},
updatedAt: new Date().toISOString(),
},
};
});
} catch (error) {
console.error(error);
setRuntimeError("Falha ao buscar livros recomendados para essa série.");
} finally {
inflightGradesRef.current.delete(grade.id);
}
}, [runtimeSchoolId, runtimePeriod, runtimeByGrade, selectedRuntimeSchool, series, setData]);
// Fluxo principal: trocou a aba (série), carrega automaticamente os livros daquela série.
useEffect(() => {
setRuntimeError("");
if (!gradeForCurrentSeries) return;
if (hasFreshCoverCache(runtimeByGrade[gradeForCurrentSeries.id])) return;
loadRuntimeRecommendationsForGrade(gradeForCurrentSeries);
}, [series, gradeForCurrentSeries, runtimeByGrade, loadRuntimeRecommendationsForGrade]);
// Mantém o contexto sincronizado com a aba ativa (mesmo quando os dados da série já estavam em cache).
useEffect(() => {
if (!gradeForCurrentSeries || !gradeForCurrentSeries.id) return;
if (runtimeSelection.gradeId === gradeForCurrentSeries.id) return;
setData((d) => ({
...d,
runtimeSelection: {
...(d.runtimeSelection || {}),
gradeId: gradeForCurrentSeries.id,
gradeName: gradeForCurrentSeries.name || gradeForCurrentSeries.id,
gradeSeriesIdx: series,
updatedAt: new Date().toISOString(),
},
}));
}, [gradeForCurrentSeries, runtimeSelection.gradeId, series, setData]);
// sourceTag namespaceia o fallback de id sintético (ver safeIdRaw abaixo)
// por origem (recomendação da turma vs. busca manual vs. busca por tema).
// Sem isso, um item de recomendação e um resultado de busca sem isbn/id
// real caíam no mesmo `runtime-${index+1}` (index é local a cada array
// mapeado, sempre começando em 1) — dois livros diferentes ganhavam o
// mesmo id, e o efeito que sincroniza pro CATALOG global (`Object.assign`
// em cima do objeto já existente, mais abaixo) sobrescrevia em memória o
// card da recomendação com os dados do livro buscado, sem mudar o
// tamanho da lista — parecia que a recomendação tinha "sumido"/sido
// substituída, quando na real os dois arrays nunca deveriam colidir.
const normalizeRuntimeBook = (item, index, sourceTag = "runtime") => {
const mapStock = (rawStock, statusText) => {
const text = String(rawStock || "").toLowerCase();
const status = String(statusText || "").toUpperCase();
if (text.includes("baix") || text.includes("indispon") || text.includes("esgotad")) return "baixo";
if (text.includes("alto") || text.includes("high") || text.includes("dispon")) return "alto";
if (text.includes("medio") || text.includes("médio") || text.includes("medium")) return "médio";
if (status.includes("APPROV")) return "alto";
return "médio";
};
const rawLang = String(item && item.lang ? item.lang : "pt").toLowerCase();
const lang = rawLang.startsWith("en") ? "en" : "pt";
const isbn = (item && item.isbn ? String(item.isbn) : "").trim();
const rawId = (item && item.id ? String(item.id) : "").trim();
const safeIdRaw = (isbn || rawId || `${sourceTag}-${index + 1}`).replace(/[^a-zA-Z0-9_-]/g, "");
const safeId = safeIdRaw || `${sourceTag}-${index + 1}`;
const status = String((item && item.status) || "").toUpperCase();
const pages = Number.isFinite(item && item.pages) ? Number(item.pages) : 0;
const stock = mapStock(item && item.stock, status);
const level = (item && item.level ? String(item.level) : "").trim();
// Sinopse real vem de item.summary (mapeada em api.js a partir da coluna
// `description` do catálogo, ou persistida no item quando o livro é
// pinado — ver buildItemFromBook/collectItemsFromGroup). Fica cru aqui
// (string vazia quando não existe) — o texto de fallback "não
// disponível" é responsabilidade de quem exibe (ver bloco de sinopse
// mais abaixo), não do dado em si: a página da família (pages-familia.jsx)
// lê esse mesmo campo direto de CATALOG e só quer mostrar o bloco
// quando existe sinopse de verdade, sem fallback nenhum.
const summary = (item && item.summary ? String(item.summary) : "").trim();
const themesFromApi = Array.isArray(item && item.themes) ? item.themes.filter(Boolean).slice(0, 5) : [];
const imageUrl = (() => {
const local = isbn && window.ISBN_COVERS && window.ISBN_COVERS[isbn];
if (local) return local;
const direct = String(
(item && (item.imageUrl || item.image || item.coverUrl)) || ""
).trim();
return direct || null;
})();
const palette = lang === "en"
? ["#2c4ffc", "#8fa2ff", "#ffffff"]
: ["#2f97a1", "#7dc7ce", "#ffffff"];
return {
id: `rt-${safeId}`,
bookId: (item && item.bookId) || rawId || null,
// Na lista do Scolist, o id do item na lista já É a identidade real
// (não existe "bookId de catálogo" separado de "id na série") — semeia
// gradeBookId a partir do id real assim que o item é carregado, não só
// depois de um pin nesta sessão, senão itens já salvos antes não
// conseguem ser removidos até serem repinados.
gradeBookId: (item && item.gradeBookId) || rawId || null,
groupName: (item && item.groupName) || "",
sampleUrl: (item && item.sampleUrl) || null,
isbn,
title: (item && item.title) || "Livro sem título",
author: (item && item.author) || "Autor não informado",
editora: (item && item.publisher) || "Editora não informada",
publisher: (item && item.publisher) || "",
provider: (item && item.provider) || "",
lang,
langLabel: lang === "en" ? "Inglês" : "Português",
series: activeSeries[series],
pages,
level: level || String(Math.max(100, 120 + (index * 7))),
stock,
stockLabel: (item && item.availabilityMessage) || stock,
price: typeof item.price === "number" ? item.price : 0,
summary,
why: (item && item.provider)
? `Livro importado da lista real da turma selecionada (${item.provider}).`
: "Livro importado da lista real da turma selecionada.",
themes: themesFromApi.length > 0 ? themesFromApi : (Array.isArray(data.themes) ? data.themes.slice(0, 4) : []),
palette,
shape: index % 2 === 0 ? "square" : "circle",
imageUrl,
};
};
const runtimeBooksForSlide = React.useMemo(
() => runtimeItems.map((item, index) => normalizeRuntimeBook(item, index, "grade")),
// eslint-disable-next-line react-hooks/exhaustive-deps
[runtimeItems, series, JSON.stringify(data.themes || [])]
);
useEffect(() => {
if (!runtimeBooksForSlide.length) return;
runtimeBooksForSlide.forEach((book) => {
const existing = CATALOG.find((catalogBook) => catalogBook.id === book.id);
if (existing) {
const keepGradeBookId = book.gradeBookId || existing.gradeBookId;
Object.assign(existing, book, { gradeBookId: keepGradeBookId });
} else {
CATALOG.push(book);
}
});
}, [runtimeBooksForSlide]);
// Todo item que já está no grupo literário salvo no backend já é, por
// definição, um livro pinado (pinBookToGrade é a única forma de um item
// entrar nesse grupo) — mas data.pinned é estado local e não nascia
// sabendo disso. Sem este seed, dar logout (que zera data.pinned) e
// logar de novo fazia a lista salva "sumir" da tela: os livros
// continuavam no Scolist, só não apareciam marcados como pinados até
// serem repinados manualmente.
useEffect(() => {
if (!runtimeBooksForSlide.length) return;
// Deduplicado: se o grupo salvo no Scolist tem mais de um item pro
// mesmo ISBN (dado antigo, de antes do fix de idempotência em
// pinBookToGrade em api.js), vários itens brutos normalizam pro mesmo
// id "rt-" — sem o Set aqui, cada um deles entrava como uma
// cópia extra em pinned[série], e o card duplicava na tela.
const idsToSeed = Array.from(new Set(runtimeBooksForSlide.map((book) => book.id)));
setData((d) => {
const prevPinned = d.pinned || {};
const existingRaw = prevPinned[series] || [];
// Limpa duplicata que já esteja salva de sessões anteriores (antes
// deste fix) — reescreve pinned[série] sem repetição, o que também
// corrige de graça a soma de preço (Step8_Pricing) e a lista final
// (Step11_Confirm/export), que leem pinned[série] direto e não tinham
// esse dedup.
const existing = Array.from(new Set(existingRaw));
const missing = idsToSeed.filter((id) => !existing.includes(id));
if (missing.length === 0 && existing.length === existingRaw.length) return d;
return { ...d, pinned: { ...prevPinned, [series]: [...existing, ...missing] } };
});
}, [runtimeBooksForSlide, series, setData]);
const isRuntimeBookId = (id) => String(id || "").startsWith("rt-");
// Not memoized on purpose: CATALOG is a mutable global array (search results
// get pushed into it outside of React state), so a memo keyed on
// runtimeBooksForSlide alone goes stale the moment a search adds a book
// that isn't part of the active grade's recommended items —
// previewSearchResult() would then silently no-op because
// runtimeCatalogById[bookId] comes back empty.
// Recomputing every render keeps this in sync with CATALOG at ~O(catalog
// size), which is small enough here not to matter.
const runtimeCatalog = (() => {
const byId = new Map();
CATALOG
.filter((book) => isRuntimeBookId(book && book.id))
.forEach((book) => byId.set(book.id, book));
// The active grade's API result is already available during this render.
// Do not wait for the CATALOG sync effect, otherwise badges/actions lag one click behind.
runtimeBooksForSlide.forEach((book) => byId.set(book.id, book));
return Array.from(byId.values());
})();
const runtimeCatalogById = Object.fromEntries(runtimeCatalog.map((book) => [book.id, book]));
// Livro do slide deve vir apenas da fonte real carregada para a série ativa.
const currentSeries = activeSeries[series];
const runtimeAppliesCurrentSeries = !!gradeForCurrentSeries && !!activeRuntimeEntry;
// Já sabemos qual turma é (gradeForCurrentSeries existe), mas o fetch
// dela (loadRuntimeRecommendationsForGrade) ainda não voltou —
// activeRuntimeEntry é null nesse meio-tempo. Sem distinguir isso de
// "carreguei e realmente não tem nada", a tela mostrava "Nenhum título
// foi adicionado ainda" — idêntico visualmente a "o livro sumiu" — só
// que era carregamento, não ausência de dado. Explica o "às vezes
// aparece, às vezes não" no refresh: depende de quão rápido a pessoa
// olha a tela em relação a esse fetch (reportado pelo Alex, 27/08/2026).
const isLoadingRuntimeData = !!gradeForCurrentSeries && !activeRuntimeEntry && !runtimeError;
const seriesBooks = runtimeAppliesCurrentSeries
? runtimeBooksForSlide
: [];
const neighbors = [];
const pool = [...seriesBooks, ...neighbors];
// Sort: PT first then EN (unless qtyPT is 0), and by within-series preference
// Build a BALANCED suggestion list: up to N/2 PT + N/2 EN, interleaved.
const rawSuggestions = pool.filter(b => b.lang === "pt" || hasEN);
const ptPool = rawSuggestions.filter(b => (b.lang || "pt") === "pt");
const enPool = rawSuggestions.filter(b => b.lang === "en");
// Interleave PT, EN, PT, EN… up to max 5+5 by default
const interleave = (a, b) => {
const out = [];
const n = Math.max(a.length, b.length);
for (let i = 0; i < n; i++) {
if (a[i]) out.push(a[i]);
if (b[i]) out.push(b[i]);
}
return out;
};
const suggestions = hasEN ? interleave(ptPool, enPool) : ptPool;
const pinned = data.pinned || {};
const pinnedForSeriesRaw = pinned[series] || [];
// dedup defensivo: mesmo se pinned[série] tiver id repetido (dado salvo
// antes do fix de duplicata), a tela nunca deve renderizar o mesmo livro
// duas vezes nem contar errado a cota.
const pinnedForSeries = Array.from(new Set(pinnedForSeriesRaw)).filter((id) => isRuntimeBookId(id) && runtimeCatalogById[id]);
const pinnedBooks = pinnedForSeries.map((id) => runtimeCatalogById[id]).filter(Boolean);
const pinnedPT = pinnedBooks.filter(b => b.lang === "pt").length;
const pinnedEN = pinnedBooks.filter(b => b.lang === "en").length;
// Show 10 ideas at a time; "Ver mais ideias" reveals +10. Pinned books are
// ALWAYS kept in the carousel so user can review/remove even if beyond shownCount.
const [shownCount, setShownCount] = useState(10);
// Preview modal state, kind is "sample" (book sample) or "guide" (teacher guide)
const [preview, setPreview] = useState(null); // { kind, book }
// Reset carousel + shown count quando troca de série. Também limpa a
// busca (query/assunto/foco): sem isso, uma busca digitada na série
// anterior ficava com o dropdown "pendurado" depois de trocar de aba, e
// clicar num resultado dali gravava o livro no histórico da série NOVA
// — previewSearchResult() usa o `series` de quando é clicado, não o de
// quando a busca foi feita, então dava pra vazar resultado de uma série
// pro histórico de outra. Pedido do Alex, 03/09/2026: "quando eu voltar
// em cada ano, tem que exibir no carousel so os livros que foram
// buscado para aqueles anos".
useEffect(() => {
setIdx(0);
setShownCount(10);
setQuery("");
setSubjectFilter("");
setSearchFocused(false);
}, [series]);
// Sinopse: "ver mais" não deve ficar expandida ao trocar de livro no carrossel
const [summaryExpanded, setSummaryExpanded] = useState(false);
useEffect(() => { setSummaryExpanded(false); }, [idx, series]);
const manualBooks = searchHistory.map((id) => runtimeCatalogById[id]).filter(Boolean);
const firstN = suggestions.slice(0, shownCount);
const extraPinned = suggestions.filter(b => pinnedForSeries.includes(b.id) && !firstN.includes(b));
const extraManual = manualBooks.filter(b => !firstN.includes(b) && !extraPinned.includes(b));
// searchHistory vai sempre na frente — é o que o usuário acabou de buscar,
// previewSearchResult() já chama setIdx(0) contando com essa ordem.
const visible = [...extraManual, ...firstN, ...extraPinned];
const safeSuggestions = visible.length ? visible : suggestions;
const hasMore = suggestions.length > shownCount;
const cur = safeSuggestions.length ? safeSuggestions[idx % safeSuggestions.length] : null;
const curWithCover = React.useMemo(() => {
if (!cur) return cur;
// Prioridade 1: capa local pelo ISBN (isbn-covers.js)
const isbnLocal = cur.isbn && window.ISBN_COVERS && window.ISBN_COVERS[String(cur.isbn).trim()];
if (isbnLocal) return { ...cur, imageUrl: isbnLocal };
if (cur.imageUrl) return cur;
const normalizeIsbn = (value) => String(value || "").replace(/\D/g, "");
const normalizedTitle = String(cur.title || "").toLowerCase().trim();
const normalizedAuthor = String(cur.author || "").toLowerCase().trim();
const normalizedIsbn = normalizeIsbn(cur.isbn);
const byIsbn = normalizedIsbn
? runtimeBooksForSlide.find((book) => normalizeIsbn(book.isbn) === normalizedIsbn && book.imageUrl)
: null;
if (byIsbn) return { ...cur, imageUrl: byIsbn.imageUrl };
const byTitle = normalizedTitle
? runtimeBooksForSlide.find((book) => {
const bookTitle = String(book.title || "").toLowerCase().trim();
const titleMatch = bookTitle === normalizedTitle || bookTitle.includes(normalizedTitle) || normalizedTitle.includes(bookTitle);
const authorMatch = !normalizedAuthor || String(book.author || "").toLowerCase().trim() === normalizedAuthor;
return titleMatch && authorMatch && book.imageUrl;
})
: null;
if (byTitle) return { ...cur, imageUrl: byTitle.imageUrl };
return cur;
}, [cur, runtimeBooksForSlide]);
const curLang = (cur && cur.lang) || "pt";
const isAtQuotaForCur = curLang === "pt" ? pinnedPT >= qtyPT : pinnedEN >= qtyEN;
const isPinnedCur = !!cur && pinnedForSeries.includes(cur.id);
const carouselArrowTop = 250; // fixed so arrows don't jump when content height changes
const nextBook = () => {
if (!safeSuggestions.length) return;
setIdx(i => (i + 1) % safeSuggestions.length);
};
const prevBook = () => {
if (!safeSuggestions.length) return;
setIdx(i => (i - 1 + safeSuggestions.length) % safeSuggestions.length);
};
// O backend não cria a série (Grade) sozinho quando o ano letivo é criado —
// só existe se alguém já chamou POST .../grade pra ela. Como o wizard não
// tem uma tela própria pra isso, criamos sob demanda ao abrir a série.
const ensureActiveGradeId = React.useCallback(async () => {
if (activeRuntimeGradeId) return activeRuntimeGradeId;
if (!window.ScolistAPI || typeof window.ScolistAPI.ensureGrade !== "function" || !runtimeSchoolId) return "";
try {
const gradeId = await window.ScolistAPI.ensureGrade(runtimeSchoolId, runtimePeriod, activeSeries[series]);
setData((d) => {
const prevSelection = d.runtimeSelection || {};
const prevGrades = Array.isArray(prevSelection.availableGrades) ? prevSelection.availableGrades : [];
if (prevGrades.some((g) => g.id === gradeId)) return d;
return {
...d,
runtimeSelection: {
...prevSelection,
availableGrades: [...prevGrades, { id: gradeId, name: activeSeries[series] }],
},
};
});
return gradeId;
} catch (error) {
console.error("Falha ao criar série:", error);
setRuntimeError("Não foi possível criar essa série.");
return "";
}
}, [activeRuntimeGradeId, runtimeSchoolId, runtimePeriod, series, setData]);
// O backend só cria a Grade sob demanda (ver comentário acima), mas até
// pouco tempo atrás isso só acontecia no primeiro pin — então uma série
// que o coordenador nunca pinou nada não tinha Grade nenhuma no backend,
// e a recomendação ficava vazia pra sempre, mesmo depois de preencher o
// onboarding inteiro (reclamação real de cliente, 11/08/2026). Agora cria
// assim que a aba da série é aberta, não só no pin.
useEffect(() => {
if (gradeForCurrentSeries || !runtimePeriod) return;
ensureActiveGradeId();
}, [series, gradeForCurrentSeries, runtimePeriod, ensureActiveGradeId]);
// Persiste pin/unpin no Scolist em segundo plano (a lista local já
// atualizou na hora — isso só reflete a mudança na lista real do backend,
// que não tem upsert por item: cada pin/unpin reenvia a lista inteira via
// PUT /list/:listId). Falha não desfaz a ação local, só avisa: o dado real
// da curadoria mora no backend, então vale tentar de novo em vez de perder
// a seleção do usuário.
const syncPinToList = React.useCallback(async (book) => {
if (!window.ScolistAPI || typeof window.ScolistAPI.pinBookToGrade !== "function") return;
if (!book || !runtimeSchoolId || !runtimePeriod) return;
const gradeId = await ensureActiveGradeId();
if (!gradeId) return;
try {
const result = await window.ScolistAPI.pinBookToGrade(runtimeSchoolId, runtimePeriod, gradeId, book);
if (result && result.id) {
book.gradeBookId = result.id;
// Mesmo formato que collectItemsFromGroup (api.js) produziria pro
// item real — mantém o cache local em sincronia com o backend
// (ver addToRuntimeItemsCache acima).
addToRuntimeItemsCache(setData, gradeId, {
id: result.id,
title: book.title,
author: book.author,
isbn: book.isbn,
publisher: book.publisher || book.editora || "",
lang: book.lang,
price: typeof book.price === "number" ? book.price : 0,
imageUrl: book.imageUrl || null,
sampleUrl: book.sampleUrl || null,
groupName: book.groupName || "",
status: "WAITING_APPROVAL",
optional: true,
observation: "",
});
}
} catch (error) {
console.error("Falha ao salvar livro na lista:", error);
setRuntimeError("Não foi possível salvar esse livro na lista. Tente de novo.");
}
}, [runtimeSchoolId, runtimePeriod, ensureActiveGradeId, setData]);
// Remove TODOS os itens crus do grupo que batem com o ISBN desse livro,
// não só o gradeBookId que o front tinha guardado — listas antigas podem
// ter mais de um item pro mesmo ISBN (bug de duplicata do pinBookToGrade,
// já corrigido, mas o dado velho ainda está salvo em algumas escolas).
// Sem isso, clicar ✕ numa dessas listas removia só um dos duplicados: o
// card sumia da tela (a UI já dedupa, ver pinnedForSeries acima) mas o
// grupo real no Scolist ainda ficava com cópia(s) sobrando.
// Devolve true/false (sucesso) — o chamador só tira o livro da tela
// depois de confirmar que o backend removeu de verdade (ver pin()/
// removeBook() abaixo). Antes essa função era chamada sem esperar
// (fogo-e-esquece) e engolia o próprio erro sem avisar quem chamou:
// se o PUT falhasse ou não terminasse antes da série recarregar, o
// efeito de seed (linha ~1234) achava o livro "faltando" localmente e
// resemeava ele de volta a partir do backend (ainda não atualizado) —
// por isso "deletar e dar refresh, o livro volta" (reportado pelo
// Alex, 27/08/2026).
const syncUnpinFromList = React.useCallback(async (book) => {
if (!window.ScolistAPI || typeof window.ScolistAPI.unpinBookFromGrade !== "function") return true;
if (!runtimeSchoolId || !runtimePeriod || !activeRuntimeGradeId) return true;
const isbn = book && book.isbn;
const byIsbn = isbn ? runtimeItems.filter((raw) => raw && raw.isbn === isbn) : [];
const idsToRemove = byIsbn.length > 0
? Array.from(new Set(byIsbn.map((raw) => raw.id).filter(Boolean)))
: [book && (book.gradeBookId || book.bookId)].filter(Boolean);
if (idsToRemove.length === 0) return true;
try {
for (const itemId of idsToRemove) {
// eslint-disable-next-line no-await-in-loop
await window.ScolistAPI.unpinBookFromGrade(runtimeSchoolId, runtimePeriod, activeRuntimeGradeId, itemId);
}
if (book) book.gradeBookId = null;
purgeFromRuntimeItemsCache(setData, activeRuntimeGradeId, idsToRemove);
return true;
} catch (error) {
console.error("Falha ao remover livro da lista:", error);
setRuntimeError("Não foi possível remover esse livro da lista. Tente de novo.");
return false;
}
}, [runtimeSchoolId, runtimePeriod, activeRuntimeGradeId, runtimeItems, setData]);
// pin/removeBook calculavam `list` a partir de `pinnedForSeries` (valor
// capturado no closure do render atual), não do estado mais recente — um
// clique duplo no botão pequeno (26x26px) disparava dois cliques antes do
// primeiro re-render, e os dois cálculos partiam do mesmo array sem o
// livro ainda, cada um adicionando cur.id por conta própria: resultado,
// o mesmo livro entrava duas vezes em pinned[series] e aparecia repetido
// lado a lado na tira de pinados (bug reportado pela Joana, reunião
// 26/08/2026: "ele copiou pro cara do lado"). Trocado pra updater
// funcional (lê o `d` mais recente) com guarda contra duplicata — mesmo
// padrão que addToSeries já usa em steps-didaticos.jsx.
// Remover agora é pessimista: só some da tela (e do localStorage, via o
// setData) depois que o backend confirmar. Pinar continua otimista —
// a reclamação era especificamente sobre remover "voltar" depois de um
// refresh, não sobre adicionar.
const [removingIds, setRemovingIds] = useState(() => new Set());
const pin = async () => {
if (!cur) return;
if (!isPinnedCur && isAtQuotaForCur) return; // blocked
if (!isPinnedCur) {
setData(d => {
const prev = (d.pinned || {})[series] || [];
const list = prev.includes(cur.id) ? prev : [...prev, cur.id];
return { ...d, pinned: { ...(d.pinned || {}), [series]: list } };
});
syncPinToList(cur);
return;
}
setRemovingIds(prev => new Set(prev).add(cur.id));
const ok = await syncUnpinFromList(cur);
setRemovingIds(prev => { const next = new Set(prev); next.delete(cur.id); return next; });
if (!ok) return; // erro já avisado por syncUnpinFromList; livro continua na lista
setData(d => {
const prev = (d.pinned || {})[series] || [];
const list = prev.filter(x => x !== cur.id);
return { ...d, pinned: { ...(d.pinned || {}), [series]: list } };
});
};
const removeBook = async (bookId) => {
const book = runtimeCatalogById[bookId];
setRemovingIds(prev => new Set(prev).add(bookId));
const ok = book ? await syncUnpinFromList(book) : true;
setRemovingIds(prev => { const next = new Set(prev); next.delete(bookId); return next; });
if (!ok) return;
setData(d => {
const prev = (d.pinned || {})[series] || [];
const list = prev.filter(x => x !== bookId);
return { ...d, pinned: { ...(d.pinned || {}), [series]: list } };
});
};
// Clicar num resultado da busca manual NÃO pina direto — só traz o livro
// pro carrossel, no mesmo formato de card de sugestão, pra o usuário ver
// detalhes (nível Scolex etc.) antes de decidir. O pin de fato só
// acontece pelo botão "Adicionar à lista" do card de detalhe (pin(),
// já existente). searchHistory (data.searchHistory, ver touchSearchHistory
// no topo do arquivo) declarado lá em cima (perto de idx/query) porque
// suggestions/visible, calculados antes deste ponto, já precisam dele.
const previewSearchResult = (bookId) => {
const book = runtimeCatalogById[bookId];
if (!book) return;
if (pinnedForSeries.includes(bookId)) return; // already there
// Sempre põe o livro clicado na frente (touchSearchHistory já
// reprependa removendo ocorrência antiga) — senão idx=0 (logo abaixo)
// mostra o pick anterior em vez do que acabou de ser buscado.
touchSearchHistory(setData, series, [bookId]);
setQuery("");
setSearchFocused(false);
setIdx(0); // searchHistory é sempre prependado em safeSuggestions
};
// Busca ao vivo na base compartilhada de livros (proxy pro Supabase via
// GET /books/search, ver README-INTEGRACAO-SCOLIST.md §8). Debounce
// simples de 350ms.
const q = query.trim().toLowerCase();
const [liveSearchResults, setLiveSearchResults] = useState([]);
const [liveSearchLoading, setLiveSearchLoading] = useState(false);
useEffect(() => {
if (query.trim().length < 2 && !subjectFilter) {
setLiveSearchResults([]);
setLiveSearchLoading(false);
return;
}
if (!window.ScolistAPI || typeof window.ScolistAPI.searchBooks !== "function") return;
let cancelled = false;
setLiveSearchLoading(true);
const handle = setTimeout(async () => {
try {
const rawResults = await window.ScolistAPI.searchBooks(query, subjectFilter ? { tags: [subjectFilter] } : undefined);
if (cancelled) return;
const normalized = rawResults.map((item, i) => normalizeRuntimeBook(item, i, "search"));
normalized.forEach((book) => {
const existing = CATALOG.find((catalogBook) => catalogBook.id === book.id);
if (existing) {
const keepGradeBookId = book.gradeBookId || existing.gradeBookId;
Object.assign(existing, book, { gradeBookId: keepGradeBookId });
} else {
CATALOG.push(book);
}
});
setLiveSearchResults(normalized);
// NÃO entra no histórico de busca (searchHistory) aqui — resultado
// só aparece no dropdown (searchResults, abaixo). Bug reportado pela
// Joana, 08/09/2026: livros com título parecido ao termo buscado
// apareciam sozinhos no carrossel de recomendação, sem o usuário ter
// clicado em nada. previewSearchResult() já registra no histórico o
// livro que o usuário de fato clicar em "ver detalhes" — só ali é
// que o livro deve entrar no carrossel.
} catch (err) {
if (!cancelled) setLiveSearchResults([]);
} finally {
if (!cancelled) setLiveSearchLoading(false);
}
}, 350);
return () => { cancelled = true; clearTimeout(handle); };
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [query, subjectFilter]);
// Quando a recomendação automática ainda não existe pra série (calibração
// pendente, ver isCalibrationPending em loadRuntimeRecommendationsForGrade)
// e a escola já escolheu temas (Step2_Themes), busca sugestões reais por
// assunto em vez de deixar a série sempre vazia (item 2,
// TAREFAS-JOANA-2026-08-20.md). Entram no histórico de busca (searchHistory)
// — mesmo tratamento de "achado por busca, ainda não decidido" já usado
// pela busca manual.
//
// Também dispara só a metade de inglês quando a série JÁ tem livros
// salvos (não é "calibração pendente") mas nenhum deles é inglês —
// sem isso, uma série que já tinha itens salvos (mesmo que todos
// errados/pt por um bug de dado antigo) nunca acionava essa busca,
// porque o gate original só olhava isCalibrationPending. Print do
// Alex/Joana, 27/08/2026: "Judy Moody Saves the World" (inglês) salvo
// como português, e "Inglês · 0/2" sem nenhuma sugestão nova pra cobrir
// a cota.
useEffect(() => {
// Temas prontos (data.themes, escola inteira) + temas próprios do
// Step2_Themes (data.customThemes), que são por escopo: "all" (toda a
// escola), "seg:" (Fundamental I/II, Médio) ou "ser:" (uma
// série específica) — ver customThemes em steps-intro.jsx:666.
// customThemes nunca era lido aqui: um tema próprio cadastrado só pro
// Fundamental I ou só pro 3º ano não tinha nenhum efeito na
// recomendação, mesmo nesse fallback onde os temas prontos já
// funcionavam.
const customThemes = data.customThemes || {};
const currentSeriesLabel = activeSeries[series];
// Step2_Themes (steps-intro.jsx) só conhece as 12 séries canônicas —
// SEGMENTS e as chaves "seg:"/"ser:" que ele grava usam sempre o nome
// canônico, nunca o rótulo customizado pela escola. Sem essa conversão,
// uma série renomeada (ex: "6º Ano - Turma Nova") nunca bateria com o
// tema próprio cadastrado pra "6º ano".
const canonicalSeriesLabel = window.inferCanonicalSeriesName ? window.inferCanonicalSeriesName(currentSeriesLabel) : currentSeriesLabel;
const segmentForSeries = (window.SEGMENTS || []).find((seg) => seg.series.includes(canonicalSeriesLabel));
const scopedCustomThemes = [
...(customThemes.all || []),
...(segmentForSeries ? (customThemes["seg:" + segmentForSeries.id] || []) : []),
...(canonicalSeriesLabel ? (customThemes["ser:" + canonicalSeriesLabel] || []) : []),
];
const themes = Array.from(new Set([
...(Array.isArray(data.themes) ? data.themes : []),
...scopedCustomThemes,
]));
const isPending = !!(activeRuntimeEntry && activeRuntimeEntry.isCalibrationPending);
const hasSomeEnInPool = runtimeBooksForSlide.some((b) => b.lang === "en");
const needsEnTopUp = !isPending && hasEN && qtyEN > 0 && !hasSomeEnInPool;
if (!activeRuntimeEntry || (!isPending && !needsEnTopUp)) return undefined;
if (themes.length === 0) return undefined;
if (!window.ScolistAPI || typeof window.ScolistAPI.searchBooks !== "function") return undefined;
let cancelled = false;
(async () => {
try {
// Busca por idioma explicitamente — sem isso, o endpoint volta uma
// única leva "misturada" que na prática é quase só português, e a
// cota de inglês da calibragem (qtyEN) nunca é preenchida mesmo
// quando a escola pediu livros em inglês (bug reportado pela Joana,
// reunião 26/08/2026: "botei 4 de inglês no calibragem e não veio
// nenhum"). O backend já suporta o filtro (`language`, ver
// BookSearchController.js) — só não estava sendo enviado daqui.
//
// Faixa de Scolex também explícita por série — sem isso, a busca
// por tema devolvia o mesmo pool de livros pra qualquer série,
// ignorando a dificuldade (bug reportado pela Joana, 27/08/2026,
// vídeo mostrando praticamente o mesmo nível de livro pra séries
// bem diferentes: "ele não está filtrando pelos colexes"). Faixa
// vem de SCOLEX_RANGE_BY_SERIES (shared.jsx), tabela que ela mandou.
// Casa pelo nome canônico da série ativa, não pela posição — a
// posição na lista de séries da escola muda conforme ela cadastra
// Educação Infantil, renomeia ou reordena séries (ver
// resolveSeriesList/scolexRangeForSeriesName em shared.jsx).
const scolexRange = window.scolexRangeForSeriesName ? window.scolexRangeForSeriesName(activeSeries[series]) : null;
const scolexOpts = scolexRange
? { scolexLevelMin: scolexRange.min, scolexLevelMax: scolexRange.max }
: {};
const searches = [];
if (isPending) searches.push(window.ScolistAPI.searchBooks(null, { tags: themes, language: "pt", ...scolexOpts }));
if (isPending || needsEnTopUp) searches.push(window.ScolistAPI.searchBooks(null, { tags: themes, language: "en", ...scolexOpts }));
const rawResults = (await Promise.all(searches)).flat();
if (cancelled || !rawResults.length) return;
const normalized = rawResults.map((item, i) => normalizeRuntimeBook(item, i, "topic"));
normalized.forEach((book) => {
const existing = CATALOG.find((catalogBook) => catalogBook.id === book.id);
if (existing) Object.assign(existing, book, { gradeBookId: book.gradeBookId || existing.gradeBookId });
else CATALOG.push(book);
});
const freshIds = normalized.map((b) => b.id).filter((id) => !pinnedForSeries.includes(id));
touchSearchHistory(setData, series, freshIds);
} catch (err) {
console.error("Falha ao buscar sugestões por tema:", err);
}
})();
return () => { cancelled = true; };
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [activeRuntimeEntry, series]);
const searchResults = (q.length >= 2 || subjectFilter)
? liveSearchResults.filter(b => !pinnedForSeries.includes(b.id)).slice(0, 8)
: [];
// Banner logic, what does the user need to do next for this série?
const ptDone = pinnedPT >= qtyPT;
const enDone = pinnedEN >= qtyEN;
const seriesDone = ptDone && enDone;
return (
Recomendações ranqueadas por nível + temas}
subtitle={hasEN
? `Para cada série: ${qtyPT} livro${qtyPT!==1?"s":""} em Português + ${qtyEN} em Inglês. Adicione os títulos que fizerem sentido, ou busque um livro específico.`
: `Para cada série: ${qtyPT} livro${qtyPT!==1?"s":""} em Português. Adicione os títulos que fizerem sentido, ou busque um livro específico.`} />
{/* Series tabs */}
{/* Book carousel */}
{isLoadingRuntimeData ? (
// Carregando de verdade (fetch em voo) — distinto de "vazio", que
// é o mesmo texto/visual de baixo. Sem essa distinção, um refresh
// mostrava "Nenhum título foi adicionado ainda" enquanto o fetch
// ainda não tinha voltado, dando a impressão errada de que um
// livro recém-adicionado/removido não persistiu.
Carregando recomendações de {activeSeries[series]}…
) : safeSuggestions.length === 0 ? (
{!runtimeSchoolId ? "Conta ainda sem escola vinculada" : !gradeForCurrentSeries ? "Turma não encontrada para esta série" : "Ainda não há livros nesta série"}
{!runtimeSchoolId
? <>Sua conta ainda não está associada a uma escola, então não há recomendação automática pra mostrar. Use a busca acima pra encontrar e adicionar títulos manualmente enquanto isso é configurado.
: !gradeForCurrentSeries
? <>Não encontramos uma turma de {activeSeries[series]} configurada pra esta escola no período atual. Verifique a configuração de turmas no login/console — enquanto isso, use a busca acima pra adicionar títulos manualmente.
: activeRuntimeEntry && activeRuntimeEntry.isCalibrationPending
? <>A recomendação automática pra {activeSeries[series]} ainda não está configurada. Use a busca acima pra encontrar e adicionar títulos manualmente.
: <>Nenhum título foi adicionado ainda pra {activeSeries[series]}. Use a busca acima pra encontrar e adicionar títulos.}
) : (
Sugestão {idx + 1} de {safeSuggestions.length} · {activeSeries[series]}
{/* Lex + balão com a sinopse do livro — antes eram dois blocos
separados (parágrafo de sinopse + "Lex sugere" com um texto de
justificativa genérico pra livros reais). Simplificado pra um
só, a pedido da Joana (item 13, TAREFAS-JOANA-2026-08-21.md).
Truncado em ~5 linhas com "ver mais/ver menos" (reunião
26/08/2026) pra sinopse grande não empurrar o resto da tela
pra baixo. */}
{(() => {
const hasSummary = !!cur.summary;
const summaryText = hasSummary ? cur.summary : "Sinopse não disponível para este título.";
return (
{summaryText}
{hasSummary && summaryText.length > 260 && (
)}
);
})()}
{/* Card "Scolex da turma": nível atual (sem projeção — reunião
03/08/2026, item 3, a projeção fica de fora até a Joana definir
a metodologia de cálculo). Mostra o dado real quando a turma já
tiver avaliação Scolex; enquanto isso (hoje, nenhuma escola
concluiu a avaliação — piloto em vendas), mostra o estado
"ainda não calculado" em vez de esconder o card. */}
{/* Ver amostra: revertido de "esconde quando não existe" (item 6,
reunião 03/08/2026) pra "mostra desabilitado com aviso" (reunião
26/08/2026) — a Joana notou o botão "sumido" e preferiu deixar
claro que a amostra não existe pro livro em vez de ele desaparecer
sem explicação. */}
{cur.sampleUrl ? (
) : (
)}
{/* Botão "Guia docente" removido por enquanto (pedido do Alex,
26/08/2026) — não é dado real de nenhum livro, é texto fixo
genérico igual pra todos. Confirmado direto na base (Supabase
prod-scolados, raw_metadata/ONIX): nenhum dos ~6.297 livros com
metadado tem guia docente de verdade (código ONIX 20), só 37
têm "instructional material" (código 39), que na prática são
instruções de uso do produto físico (livro-quebra-cabeça,
cartonado), não guia pedagógico. Ver TAREFAS-JOANA-2026-08-26.md.
O modal (kind "guide", mais abaixo) continua no código, só sem
botão que abra ele — reativa fácil se aparecer uma fonte real.
*/}
{isAtQuotaForCur && !isPinnedCur ? (
ℹ️
Você já atingiu a cota de {curLang === "pt" ? "Português" : "Inglês"} para {activeSeries[series]}.
{curLang === "pt" && !enDone && hasEN && <> Falta{qtyEN-pinnedEN>1?"m":""} {qtyEN-pinnedEN} em Inglês.}
{curLang === "en" && !ptDone && <> Falta{qtyPT-pinnedPT>1?"m":""} {qtyPT-pinnedPT} em Português.}
) : isPinnedCur ? (
✓ Na lista
) : (
⊕ Adicionar à lista
)}
Ver outra opção →
)}
{/* Ver mais ideias, keeps pinned books in carousel; reveals +10 */}
{safeSuggestions.length > 0 && hasMore && (
)}
{/* Pinned strip for current series, split by language. Enquanto
isLoadingRuntimeData, nem mostra — "0/N" com a grade vazia aqui
é o mesmo visual enganoso do bloco de sugestões acima. */}
{isLoadingRuntimeData ? (
{preview.kind === "sample" ? "Amostra do livro" : "Guia docente"}
{preview.book.title}
{/* Watermark notice */}
🔒Pré-visualização apenas, conteúdo protegido por direitos autorais, não pode ser baixado ou impresso.
{/* Preview body */}
preview.kind !== "sample" && e.preventDefault()}>
{preview.kind === "sample" ? (
preview.book.sampleUrl ? (
// #toolbar=0 esconde a barra nativa do visualizador de PDF do
// Chrome (zoom, girar, e principalmente baixar/imprimir) —
// sem isso, o Chrome desenha a própria barra dentro do
// iframe por cima do aviso de "não pode ser baixado ou
// impresso" logo acima, com um botão de download bem ali.
// É só a UI nativa escondida (não é DRM de verdade: o
// arquivo em si continua acessível por quem inspecionar a
// aba de rede), mas resolve o pedido do Alex de não exibir
// esse painel do Chrome.
) : (
Amostra não disponível para este livro.
)
) : (
SCOLIST
Guia docente
{preview.book.title}
Objetivos pedagógicos
Desenvolver a compreensão leitora e a capacidade de inferência.
Trabalhar vocabulário específico da faixa etária.
Estimular discussões sobre os temas centrais da obra.
Perguntas para debate
O que mais chamou sua atenção no comportamento dos personagens?
Que situação do livro se parece com algo que você já viveu?
Como você se sentiria no lugar do protagonista?
Atividades sugeridas
Escrita criativa: reescrever um capítulo da perspectiva de outro personagem.
Arte: ilustrar a cena favorita, justificando a escolha.
Roda de conversa sobre os temas trabalhados.
)}
)}
);
}
// Step 11: Revisão consolidada, todas as séries com livros escolhidos
function Step10_Detail() {
const { data, setData } = useApp();
// Séries de verdade da escola (Passo 1), não a lista fixa de 12.
const activeSeries = resolveSeriesList(data);
const pinned = data.pinned || {};
const isRuntimeBookId = (id) => String(id || "").startsWith("rt-");
const runtimeCatalog = CATALOG.filter((book) => isRuntimeBookId(book && book.id));
const runtimeCatalogById = Object.fromEntries(runtimeCatalog.map((book) => [book.id, book]));
// dedup defensivo — mesmo motivo do Step9_Recommend (pinned[série] pode
// ter id repetido em dado salvo antes do fix de duplicata em
// pinBookToGrade, api.js)
const pinnedIdsForSeries = (si) => Array.from(new Set(pinned[si] || [])).filter((id) => isRuntimeBookId(id) && runtimeCatalogById[id]);
const hasEN = data.scolexEN !== "none";
const qtyPT = data.qtyPerYearPT ?? (data.qtyPerYear ?? 3);
const qtyEN = hasEN ? (data.qtyPerYearEN ?? 2) : 0;
const bimestres = data.bimestres || {};
const { count: periodCount, label: periodLabel, labelPlural: periodLabelPlural } = periodInfo(data);
const [dragOver, setDragOver] = useState(null); // {si, bn}
const [dragging, setDragging] = useState(null); // {si, bookId}
const [removingIds, setRemovingIds] = useState(() => new Set());
const setBim = (si, bookId, bn) => {
setData(d => {
const all = { ...(d.bimestres || {}) };
const forSeries = { ...(all[si] || {}) };
if (bn === 0 || bn == null) delete forSeries[bookId];
else forSeries[bookId] = bn;
all[si] = forSeries;
return { ...d, bimestres: all };
});
};
// Stats globais
const allPinnedIds = activeSeries.flatMap((_, si) => pinnedIdsForSeries(si));
const totalBooks = allPinnedIds.length;
const expectedTotal = activeSeries.length * (qtyPT + qtyEN);
const seriesDoneCount = activeSeries.filter((_, si) => {
const ids = pinnedIdsForSeries(si);
const pt = ids.filter((id) => { const b = runtimeCatalogById[id]; return b && (b.lang || "pt") === "pt"; }).length;
const en = ids.filter((id) => { const b = runtimeCatalogById[id]; return b && b.lang === "en"; }).length;
return pt >= qtyPT && (!hasEN || en >= qtyEN);
}).length;
const runtimeSelection = data.runtimeSelection || {};
const runtimeGrades = Array.isArray(runtimeSelection.availableGrades) ? runtimeSelection.availableGrades : [];
const runtimePeriod = runtimeSelection.period || String(new Date().getFullYear());
const runtimeSchoolId = runtimeSelection.schoolId || "";
// Pessimista: só tira da tela (e do localStorage) depois que o backend
// confirmar a remoção — antes era fogo-e-esquece, então um refresh
// rápido depois de clicar ✕ podia "trazer o livro de volta", porque o
// efeito de seed (Step9_Recommend) resemeia a partir do que ainda
// estivesse salvo no Scolist se o PUT não tivesse terminado a tempo
// (bug reportado pelo Alex, 27/08/2026).
const removeBook = async (seriesIdx, bookId) => {
const book = runtimeCatalogById[bookId];
const grade = findGradeForSeriesIndex(runtimeGrades, seriesIdx, activeSeries);
// Mesmo motivo do fix em syncUnpinFromList (Step9_Recommend): remove
// todo item cru com o mesmo ISBN, não só o gradeBookId que o front
// guardou — lista antiga pode ter mais de um item pro mesmo livro.
const rawItems = (grade && data.runtimeSelection && data.runtimeSelection.recommendedByGradeId
&& data.runtimeSelection.recommendedByGradeId[grade.id]
&& data.runtimeSelection.recommendedByGradeId[grade.id].items) || [];
const byIsbn = book && book.isbn ? rawItems.filter((raw) => raw && raw.isbn === book.isbn) : [];
const idsToRemove = byIsbn.length > 0
? Array.from(new Set(byIsbn.map((raw) => raw.id).filter(Boolean)))
: [book && (book.gradeBookId || book.bookId)].filter(Boolean);
let ok = true;
if (window.ScolistAPI && typeof window.ScolistAPI.unpinBookFromGrade === "function" && idsToRemove.length > 0 && runtimeSchoolId && grade && grade.id) {
setRemovingIds(prev => new Set(prev).add(bookId));
try {
for (const itemId of idsToRemove) {
// eslint-disable-next-line no-await-in-loop
await window.ScolistAPI.unpinBookFromGrade(runtimeSchoolId, runtimePeriod, grade.id, itemId);
}
if (book) book.gradeBookId = null;
purgeFromRuntimeItemsCache(setData, grade.id, idsToRemove);
} catch (error) {
// Step10_Detail não tem o banner de runtimeError que o
// Step9_Recommend tem — só loga, mesmo comportamento de antes.
console.error("Falha ao remover livro da lista:", error);
ok = false;
} finally {
setRemovingIds(prev => { const next = new Set(prev); next.delete(bookId); return next; });
}
}
if (!ok) return;
setData(d => {
const prev = ((d.pinned || {})[seriesIdx] || []).filter((id) => isRuntimeBookId(id));
const list = prev.filter(id => id !== bookId);
return { ...d, pinned: { ...(d.pinned || {}), [seriesIdx]: list } };
});
};
return (
Confira tudo antes de seguir. Você pode remover ou trocar qualquer título voltando pro carrossel da série.} />
{/* Stats bar */}
{(() => {
// Só conta marcações dentro da faixa do calendário atual — uma tag
// de "4º bimestre" salva antes de trocar pra trimestre não é mais
// válida (não aparece em nenhuma lane) e não deve contar aqui.
const totalBim = Object.values(bimestres).reduce((s, m) => s + Object.values(m || {}).filter(v => v >= 1 && v <= periodCount).length, 0);
const bimColor = totalBim === totalBooks && totalBooks > 0 ? "var(--teal-dark)" : "var(--text)";
return (
{`${periodLabelPlural} marcados`}
{totalBim} de {totalBooks}
{`arraste pro ${periodLabel} certo`}
);
})()}
Aqui está a lista toda. {`Arraste cada livro pro ${periodLabel}`} em que vai usar — ou clique pra ciclar. Use o ✕ pra remover.
{/* Grid de séries */}
{/* fade na borda direita pra conectar com o texto */}
{/* glow verde ambiente */}
{/* Texto à direita */}