@webround/editor 0.0.0-stage → 0.3.0

package/dist/vite-plugins/jsx-tree.js

@@ -0,0 +1,686 @@
+// Il TSX di una pagina letto e scritto come albero JSX: trovare un nodo per id e INSERIRE markup.
+//
+// Il contratto dell'inserimento è codice: JSX, lo stesso per l'interfaccia visuale, per chi scrive a mano e per un'AI. Questo modulo
+// non impone una rappresentazione intermedia: valida, sceglie gli id, indenta, importa e scrive, in modo atomico. Se qualunque
+// passo fallisce il file non viene toccato.
+//
+// Solo ts-morph, niente Vite né filesystem diretto: si prova con un Project in memoria (vedi test/insert.test.ts).
+import { SyntaxKind, ts, } from 'ts-morph';
+import { WR_COMPONENT_TO_KIND, wrTakesChildren } from '@webround/core/kinds';
+export function toFullNode(node) {
+    if (node.getKind() === SyntaxKind.JsxSelfClosingElement)
+        return node;
+    const full = node.getParentIfKind(SyntaxKind.JsxElement);
+    if (!full)
+        throw new Error('JsxOpeningElement senza JsxElement genitore: file corrotto?');
+    return full;
+}
+export function loadSourceFile(project, filePath) {
+    const existing = project.getSourceFile(filePath);
+    if (existing) {
+        existing.refreshFromFileSystemSync();
+        return existing;
+    }
+    return project.addSourceFileAtPathIfExists(filePath);
+}
+/** Il valore letterale (stringa) dell'attributo `id` di un tag, se c'è ed è letterale. */
+function literalId(node) {
+    const attr = node.getAttribute('id');
+    if (!attr || attr.getKind() !== SyntaxKind.JsxAttribute)
+        return null;
+    const init = attr.getInitializer?.();
+    return init?.getKind() === SyntaxKind.StringLiteral ? init.getLiteralValue() : null;
+}
+export function findNode(project, filePath, id) {
+    const sourceFile = loadSourceFile(project, filePath);
+    if (!sourceFile)
+        return null;
+    for (const node of tagNodes(sourceFile)) {
+        const kind = WR_COMPONENT_TO_KIND[node.getTagNameNode().getText()];
+        if (kind && literalId(node) === id)
+            return { node, full: toFullNode(node), kind };
+    }
+    return null;
+}
+function tagNodes(root) {
+    return [
+        ...root.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...root.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ];
+}
+/** Gli id letterali di tutti i componenti Wr* di un file. */
+export function collectFileIds(sourceFile) {
+    const ids = new Set();
+    for (const node of tagNodes(sourceFile)) {
+        if (!WR_COMPONENT_TO_KIND[node.getTagNameNode().getText()])
+            continue;
+        const id = literalId(node);
+        if (id !== null)
+            ids.add(id);
+    }
+    return ids;
+}
+export function getIndent(node) {
+    const text = node.getSourceFile().getFullText();
+    const lineStart = text.lastIndexOf('\n', node.getStart() - 1) + 1;
+    return text.slice(lineStart, node.getStart()).match(/^[ \t]*/)?.[0] ?? '';
+}
+/** Il nome locale con cui un identificatore è già importato nel file, da qualunque modulo. */
+function importedNames(sourceFile) {
+    const names = new Set();
+    for (const decl of sourceFile.getImportDeclarations()) {
+        for (const named of decl.getNamedImports())
+            names.add(named.getAliasNode()?.getText() ?? named.getName());
+        const def = decl.getDefaultImport();
+        if (def)
+            names.add(def.getText());
+        const ns = decl.getNamespaceImport();
+        if (ns)
+            names.add(ns.getText());
+    }
+    return names;
+}
+/**
+ * Importa da `@webround/core` i componenti che servono, se il file non li importa già: da dove non importa. Un file che prende
+ * `WrImage` da `@webround/editor` lo tiene così, e non ne ottiene un secondo (un identificatore duplicato non compila).
+ */
+export function ensureImports(sourceFile, names) {
+    const already = importedNames(sourceFile);
+    const missing = names.filter(name => !already.has(name));
+    if (missing.length === 0)
+        return;
+    const moduleSpecifier = '@webround/core';
+    let importDecl = sourceFile.getImportDeclaration(d => d.getModuleSpecifierValue() === moduleSpecifier);
+    if (!importDecl)
+        importDecl = sourceFile.addImportDeclaration({ moduleSpecifier, namedImports: [] });
+    // Come testo, in coda all'ultimo specificatore: l'import che l'utente ha impaginato (anche su più righe) resta com'è,
+    // e togliere il nome (l'annulla) rida' il file identico. ts-morph, qui, rifarebbe l'impaginazione.
+    for (const name of missing) {
+        const decl = sourceFile.getImportDeclaration(d => d.getModuleSpecifierValue() === moduleSpecifier);
+        const specs = decl.getNamedImports();
+        const last = specs[specs.length - 1];
+        if (last)
+            sourceFile.insertText(last.getEnd(), `, ${name}`);
+        else
+            decl.addNamedImport(name);
+    }
+}
+const unwrap = (node) => {
+    let current = node;
+    while (current && current.getKind() === SyntaxKind.ParenthesizedExpression)
+        current = current.getExpression();
+    return current;
+};
+const isJsxRoot = (node) => !!node && (node.getKind() === SyntaxKind.JsxElement || node.getKind() === SyntaxKind.JsxFragment || node.getKind() === SyntaxKind.JsxSelfClosingElement);
+/**
+ * `<WrShared name="…">` (the root of a shared component) is not an element of the page: what it holds is. A component that returns just one
+ * element inside it has THAT as its root, like a header does: nothing can be put next to it, it cannot be deleted or moved.
+ */
+function insideShared(root) {
+    if (!root.isKind(SyntaxKind.JsxElement) || root.getOpeningElement().getTagNameNode().getText() !== 'WrShared')
+        return root;
+    const children = root.getJsxChildren().filter(child => !(child.isKind(SyntaxKind.JsxText) && child.getText().trim() === ''));
+    return children.length === 1 && isJsxRoot(children[0]) ? children[0] : root;
+}
+/** La radice JSX restituita da una funzione componente (corpo a blocco o a espressione). */
+function rootOfComponent(fn) {
+    const body = fn?.getBody?.();
+    if (!body)
+        return null;
+    if (body.getKind() !== SyntaxKind.Block) {
+        const direct = unwrap(body);
+        return isJsxRoot(direct) ? insideShared(direct) : null;
+    }
+    for (const statement of body.getStatements()) {
+        if (statement.getKind() !== SyntaxKind.ReturnStatement)
+            continue;
+        const returned = unwrap(statement.getExpression());
+        if (isJsxRoot(returned))
+            return insideShared(returned);
+    }
+    return null;
+}
+/**
+ * La radice JSX del componente del file: quello esportato di default (`export default function Home() { return (<>…</>); }`) o, se
+ * il file non ha un default, il primo componente esportato per nome che restituisce JSX (`export function Header() { … }`, i file di
+ * `src/layout/`).
+ */
+export function findPageRoot(sourceFile) {
+    const declarations = sourceFile.getDefaultExportSymbol()?.getDeclarations() ?? [];
+    for (const declaration of declarations) {
+        let fn = declaration;
+        if (declaration.getKind() === SyntaxKind.ExportAssignment) {
+            fn = unwrap(declaration.getExpression());
+            // `export default Home;` → il componente dichiarato nel file
+            if (fn?.getKind() === SyntaxKind.Identifier) {
+                const name = fn.getText();
+                fn = sourceFile.getFunction(name) ?? sourceFile.getVariableDeclaration(name)?.getInitializer();
+            }
+        }
+        const root = rootOfComponent(fn);
+        if (root)
+            return root;
+    }
+    if (declarations.length > 0)
+        return null;
+    for (const [, exported] of sourceFile.getExportedDeclarations()) {
+        for (const declaration of exported) {
+            const fn = declaration.getKind() === SyntaxKind.VariableDeclaration ? declaration.getInitializer?.() : declaration;
+            const root = rootOfComponent(fn);
+            if (root)
+                return root;
+        }
+    }
+    return null;
+}
+/** Dentro un'espressione (`{cond && <X/>}`, `{items.map(...)}`, una render prop): il codice decide cosa c'è, non si inserisce lì. */
+function isGeneratedByCode(node) {
+    for (let current = node.getParent(); current; current = current.getParent()) {
+        if (current.getKind() === SyntaxKind.JsxExpression)
+            return true;
+    }
+    return false;
+}
+const fail = (status, code, error) => ({ ok: false, status, code, error });
+const SNIPPET_PREFIX = 'const __wr = <>';
+const SNIPPET_SUFFIX = '</>;';
+function parseTsx(text) {
+    return ts.createSourceFile('snippet.tsx', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+/** What the parser could not read: the message and the line of each problem (an unclosed tag, a stray token…). */
+export function syntaxErrors(sf) {
+    const diagnostics = sf.parseDiagnostics ?? [];
+    return diagnostics.map(d => ({
+        message: ts.flattenDiagnosticMessageText(d.messageText, '\n'),
+        line: sf.getLineAndCharacterOfPosition(d.start ?? 0).line + 1,
+    }));
+}
+function syntaxError(sf) {
+    const first = syntaxErrors(sf)[0];
+    return first ? `${first.message} (line ${first.line})` : null;
+}
+const applyEdits = (text, edits) => [...edits].sort((a, b) => b.pos - a.pos).reduce((acc, e) => acc.slice(0, e.pos) + e.text + acc.slice(e.end), text);
+/** `hero-2` → `hero`: the base a new number is added to. */
+const baseOf = (id) => id.replace(/-\d+$/, '');
+function freeId(base, taken, firstNumber) {
+    for (let n = firstNumber;; n++) {
+        const candidate = `${base}-${n}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+}
+function prepareSnippet(rawJsx, taken, uniqueIds) {
+    if (!rawJsx.trim())
+        return fail(400, 'invalid-jsx', 'the markup is empty');
+    const wrapped = SNIPPET_PREFIX + rawJsx + SNIPPET_SUFFIX;
+    const sf = parseTsx(wrapped);
+    const problem = syntaxError(sf);
+    if (problem)
+        return fail(400, 'invalid-jsx', problem);
+    const statement = sf.statements[0];
+    const fragment = statement?.declarationList.declarations[0]?.initializer;
+    if (!fragment || !ts.isJsxFragment(fragment))
+        return fail(400, 'invalid-jsx', 'the markup is not a list of JSX elements');
+    // Il primo livello: solo elementi (e spazi), di qualunque tag
+    const top = fragment.children.filter(child => !(ts.isJsxText(child) && child.containsOnlyTriviaWhiteSpaces));
+    if (top.length === 0)
+        return fail(400, 'invalid-jsx', 'the markup has no elements');
+    for (const child of top) {
+        if (!ts.isJsxElement(child) && !ts.isJsxSelfClosingElement(child))
+            return fail(400, 'invalid-jsx', 'only JSX elements can be inserted at the top level');
+    }
+    // Tutti i tag, nell'ordine del documento
+    const tags = [];
+    const visit = (node) => {
+        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node))
+            tags.push(node);
+        ts.forEachChild(node, visit);
+    };
+    visit(fragment);
+    const edits = [];
+    const ids = [];
+    const idMap = {};
+    const used = new Set(taken);
+    const finalIdOf = new Map();
+    const usedTags = new Set();
+    for (const tag of tags) {
+        const name = tag.tagName.getText(sf);
+        const kind = WR_COMPONENT_TO_KIND[name];
+        // Anything that is not one of ours (an HTML tag, the developer's own component, even a "Wr..." that is theirs) is left alone
+        if (!kind)
+            continue;
+        usedTags.add(name);
+        const attr = tag.attributes.properties.find(p => ts.isJsxAttribute(p) && p.name.getText(sf) === 'id');
+        const literal = attr?.initializer && ts.isStringLiteral(attr.initializer) ? attr.initializer : undefined;
+        // `id={something}`: the developer's business. The editor cannot find such an element, and does not count it.
+        if (attr && !literal)
+            continue;
+        let finalId;
+        if (!literal) {
+            finalId = freeId(kind, used, 1);
+            const at = tag.tagName.getEnd() - SNIPPET_PREFIX.length;
+            edits.push({ pos: at, end: at, text: ` id="${finalId}"` });
+        }
+        else if (used.has(literal.text)) {
+            if (!uniqueIds)
+                return fail(409, 'id-exists', `id already exists: ${literal.text}`);
+            finalId = freeId(baseOf(literal.text), used, 2);
+            idMap[literal.text] = finalId;
+            edits.push({ pos: literal.getStart(sf) - SNIPPET_PREFIX.length, end: literal.getEnd() - SNIPPET_PREFIX.length, text: `"${finalId}"` });
+        }
+        else {
+            finalId = literal.text;
+        }
+        used.add(finalId);
+        ids.push(finalId);
+        finalIdOf.set(tag, finalId);
+    }
+    const jsx = applyEdits(rawJsx, edits);
+    const rootIds = top.map(child => finalIdOf.get(ts.isJsxElement(child) ? child.openingElement : child)).filter((id) => id !== undefined);
+    return { jsx, ids, rootIds, undoable: rootIds.length === top.length, idMap, tags: [...usedTags] };
+}
+// ── Dove, e con quale indentazione ───────────────────────────────────────────────────────
+/** L'unità di indentazione del file: tab, o il rientro più piccolo che vi compare (2 o 4 spazi di solito). */
+export function detectIndentUnit(text) {
+    let smallest = Infinity;
+    for (const line of text.split('\n')) {
+        if (!line.trim())
+            continue;
+        if (line.startsWith('\t'))
+            return '\t';
+        const spaces = line.match(/^ +/)?.[0].length ?? 0;
+        if (spaces > 0 && spaces < smallest)
+            smallest = spaces;
+    }
+    return Number.isFinite(smallest) ? ' '.repeat(Math.min(smallest, 8)) : '    ';
+}
+/** Toglie il rientro comune a tutte le righe non vuote. */
+function dedent(text) {
+    const lines = text.replace(/^\s*\n/, '').trimEnd().split('\n');
+    const indents = lines.filter(l => l.trim()).map(l => l.match(/^[ \t]*/)[0].length);
+    const common = indents.length ? Math.min(...indents) : 0;
+    return lines.map(l => l.slice(common)).join('\n');
+}
+/**
+ * Rifà i rientri interni del markup con l'unità del file: un blocco scritto a 2 spazi in un file a 4 (o a tab) non deve
+ * lasciare un solo livello "storto". Il rientro comune è già tolto (`dedent`); qui si convertono i livelli.
+ */
+export function reindent(text, unit) {
+    const lead = (l) => l.match(/^[ \t]*/)[0];
+    const lines = text.split('\n');
+    const own = lines.filter(l => l.trim() && lead(l)).map(l => lead(l));
+    if (!own.length)
+        return text;
+    const ownUnit = own.some(l => l.includes('\t')) ? '\t' : ' '.repeat(Math.min(...own.map(l => l.length)));
+    if (ownUnit === unit)
+        return text;
+    return lines.map(l => {
+        if (!l.trim())
+            return l;
+        const ws = lead(l);
+        const levels = ownUnit === '\t' ? ws.split('\t').length - 1 : Math.round(ws.length / ownUnit.length);
+        return unit.repeat(levels) + l.slice(ws.length);
+    }).join('\n');
+}
+const indentLines = (text, prefix) => text.split('\n').map(l => (l ? prefix + l : l)).join('\n');
+/** Il rientro dei figli di un contenitore: quello del suo primo figlio elemento, se ne ha; altrimenti il suo più un'unità. */
+function childIndent(container, unit) {
+    if (container.getKind() !== SyntaxKind.JsxSelfClosingElement) {
+        const first = container.getJsxChildren().find(c => c.getKind() === SyntaxKind.JsxElement || c.getKind() === SyntaxKind.JsxSelfClosingElement);
+        if (first)
+            return getIndent(first);
+    }
+    return getIndent(container) + unit;
+}
+/** Il nuovo testo del file, con il markup inserito dove dice `mode` rispetto a `target`. */
+function insertionEdit(text, target, mode, markup, unit) {
+    const own = getIndent(target);
+    const kind = target.getKind();
+    if (mode === 'before') {
+        const pos = target.getStart();
+        return { pos, end: pos, text: indentLines(markup, own).slice(own.length) + '\n' + own };
+    }
+    if (mode === 'after') {
+        const pos = target.getEnd();
+        return { pos, end: pos, text: '\n' + indentLines(markup, own) };
+    }
+    const inner = childIndent(target, unit);
+    if (kind === SyntaxKind.JsxSelfClosingElement) {
+        // `<WrSection id="s" />` → `<WrSection id="s">` + figlio + `</WrSection>`
+        const node = target;
+        const open = node.getText().replace(/\s*\/>$/, '>');
+        const tag = node.getTagNameNode().getText();
+        return { pos: node.getStart(), end: node.getEnd(), text: `${open}\n${indentLines(markup, inner)}\n${own}</${tag}>` };
+    }
+    const container = target;
+    if (mode === 'first-child') {
+        const pos = kind === SyntaxKind.JsxFragment ? container.getOpeningFragment().getEnd() : container.getOpeningElement().getEnd();
+        return { pos, end: pos, text: '\n' + indentLines(markup, inner) };
+    }
+    // last-child: subito prima del tag di chiusura, che sta già su una riga sua con il rientro del contenitore
+    const closing = kind === SyntaxKind.JsxFragment ? container.getClosingFragment() : container.getClosingElement();
+    const closingLineStart = text.lastIndexOf('\n', closing.getStart() - 1) + 1;
+    const beforeClosing = text.slice(closingLineStart, closing.getStart());
+    if (/^[ \t]*$/.test(beforeClosing)) {
+        return { pos: closingLineStart, end: closingLineStart, text: indentLines(markup, inner) + '\n' };
+    }
+    // il tag di chiusura sta in fondo a una riga con altro contenuto: va a capo
+    return { pos: closing.getStart(), end: closing.getStart(), text: '\n' + indentLines(markup, inner) + '\n' + own };
+}
+/**
+ * Inserisce markup JSX in un file: valida, sceglie gli id, indenta, aggiunge gli import e scrive. Atomico: o il file è cambiato come
+ * richiesto, o non è cambiato.
+ */
+export function insertJsx(project, filePath, request) {
+    const { anchor, mode } = request;
+    const sourceFile = loadSourceFile(project, filePath);
+    if (!sourceFile)
+        return fail(404, 'anchor-not-found', 'file not found');
+    const original = sourceFile.getFullText();
+    // 1. Il bersaglio
+    let target;
+    if ('root' in anchor) {
+        if (mode !== 'first-child' && mode !== 'last-child')
+            return fail(400, 'invalid-mode', 'the page root takes children only: use "first-child" or "last-child"');
+        const root = findPageRoot(sourceFile);
+        if (!root)
+            return fail(422, 'no-page-root', 'no JSX root found: the default export of the page must return JSX');
+        target = root;
+    }
+    else {
+        const found = findNode(project, filePath, anchor.id);
+        if (!found)
+            return fail(404, 'anchor-not-found', `no element with id "${anchor.id}"`);
+        if (isGeneratedByCode(found.full))
+            return fail(422, 'generated-by-code', `"${anchor.id}" is generated by code (inside {...}): nothing can be added around or inside it from the editor`);
+        if ((mode === 'before' || mode === 'after') && findPageRoot(sourceFile) === found.full) {
+            return fail(422, 'component-root', `"${anchor.id}" is the only element its component returns (the root of a header or a footer): put the block inside it, not next to it`);
+        }
+        if ((mode === 'before' || mode === 'after')) {
+            const parent = found.full.getParent();
+            if (!parent || (parent.getKind() !== SyntaxKind.JsxElement && parent.getKind() !== SyntaxKind.JsxFragment)) {
+                return fail(422, 'generated-by-code', `"${anchor.id}" is not a direct child in JSX: nothing can be added next to it`);
+            }
+        }
+        if ((mode === 'first-child' || mode === 'last-child') && !wrTakesChildren(found.kind)) {
+            return fail(422, 'not-a-container', `<${found.node.getTagNameNode().getText()}> does not take children: put the block next to it (before or after)`);
+        }
+        target = found.full;
+    }
+    // 2. Il markup
+    const unit = detectIndentUnit(original);
+    const prepared = prepareSnippet(reindent(dedent(request.jsx), unit), collectFileIds(sourceFile), request.uniqueIds !== false);
+    if ('ok' in prepared)
+        return prepared;
+    // 3. Il nuovo testo, controllato prima di scrivere
+    const edit = insertionEdit(original, target, mode, prepared.jsx, unit);
+    const next = applyEdits(original, [edit]);
+    const problem = syntaxError(parseTsx(next));
+    if (problem)
+        return fail(500, 'invalid-result', `the insertion would leave the file invalid, nothing was written: ${problem}`);
+    // 4. Scrittura e import; se qualcosa fallisce il file torna com'era
+    try {
+        sourceFile.replaceWithText(next);
+        ensureImports(sourceFile, prepared.tags);
+        sourceFile.saveSync();
+    }
+    catch (err) {
+        sourceFile.replaceWithText(original);
+        sourceFile.saveSync();
+        return fail(500, 'invalid-result', String(err));
+    }
+    return { ok: true, ids: prepared.ids, rootIds: prepared.rootIds, undoable: prepared.undoable, idMap: prepared.idMap, jsx: prepared.jsx };
+}
+// ── Cancellare un sottoalbero (e sapere dove stava, per l'undo) ──────────────────────────
+// Tutti i tag JSX (self-closing e di apertura) dentro `root`, root incluso se è un self-closing.
+function getJsxTagNodes(root) {
+    return [
+        ...(root.getKind() === SyntaxKind.JsxSelfClosingElement ? [root] : []),
+        ...root.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...root.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ];
+}
+// Id letterali dei componenti Wr* dentro `full` (se stesso incluso), senza duplicati.
+function collectSubtreeIds(full) {
+    const ids = new Set();
+    for (const node of getJsxTagNodes(full)) {
+        if (!WR_COMPONENT_TO_KIND[node.getTagNameNode().getText()])
+            continue;
+        const idAttr = node.getAttribute('id');
+        if (!idAttr || idAttr.getKind() !== SyntaxKind.JsxAttribute)
+            continue;
+        const init = idAttr.getInitializer?.();
+        if (init?.getKind() === SyntaxKind.StringLiteral)
+            ids.add(init.getLiteralValue());
+    }
+    return [...ids];
+}
+// Identificatori "radice" dei tag usati nel sottoalbero (`Foo` per `<Foo.Bar>`),
+// esclusi i tag HTML intrinseci (minuscoli). Da calcolare PRIMA di rimuovere il nodo.
+function collectSubtreeTagHeads(full) {
+    const heads = new Set();
+    for (const node of getJsxTagNodes(full)) {
+        const head = node.getTagNameNode().getText().split('.')[0];
+        if (/^[A-Z]/.test(head))
+            heads.add(head);
+    }
+    return heads;
+}
+// Dove stava il nodo prima di essere cancellato, per poterlo reinserire esattamente
+// lì con l'undo: il fratello JSX precedente con un id noto, o — se non c'è, perché
+// era il primo figlio — il genitore (inserimento come primo figlio), o la radice della pagina.
+function getAnchor(full) {
+    const idOf = (opening) => {
+        const idAttr = opening.getAttribute('id');
+        const init = idAttr?.getKind() === SyntaxKind.JsxAttribute ? idAttr.getInitializer?.() : null;
+        return init?.getKind() === SyntaxKind.StringLiteral ? init.getLiteralValue() : null;
+    };
+    let sibling = full.getPreviousSibling();
+    while (sibling) {
+        if (sibling.getKind() === SyntaxKind.JsxElement || sibling.getKind() === SyntaxKind.JsxSelfClosingElement) {
+            const openingTag = sibling.getKind() === SyntaxKind.JsxSelfClosingElement
+                ? sibling
+                : sibling.getOpeningElement();
+            const id = WR_COMPONENT_TO_KIND[openingTag.getTagNameNode().getText()] ? idOf(openingTag) : null;
+            if (id !== null)
+                return { anchor: { id }, anchorMode: 'after' };
+        }
+        sibling = sibling.getPreviousSibling();
+    }
+    const parent = full.getParentIfKind(SyntaxKind.JsxElement);
+    if (parent) {
+        const id = idOf(parent.getOpeningElement());
+        if (id !== null)
+            return { anchor: { id }, anchorMode: 'first-child' };
+    }
+    // Il primo figlio diretto della radice della pagina (che non ha id): si torna a inserirlo in cima alla pagina
+    const root = findPageRoot(full.getSourceFile());
+    const container = full.getParent();
+    if (root && container && container === root)
+        return { anchor: { root: true }, anchorMode: 'first-child' };
+    return { anchor: null, anchorMode: 'first-child' };
+}
+/** L'id letterale di un tag, se ce l'ha. */
+function idOfJsx(opening) {
+    const idAttr = opening?.getAttribute('id');
+    const init = idAttr?.getKind() === SyntaxKind.JsxAttribute ? idAttr.getInitializer?.() : null;
+    return init?.getKind() === SyntaxKind.StringLiteral ? init.getLiteralValue() : null;
+}
+/**
+ * Un elemento che resta senza figli torna `<X … />`: è l'inverso di un inserimento dentro un elemento che si apre per accogliere un
+ * figlio, e così annullare riporta il file com'era. (Solo se dentro non c'è altro che spazi.)
+ */
+function closeIfEmpty(sourceFile, id) {
+    // Sul file com'è adesso in memoria (la cancellazione non è ancora salvata): findNode lo rileggerebbe dal disco
+    const element = sourceFile.getDescendantsOfKind(SyntaxKind.JsxElement).find(e => idOfJsx(e.getOpeningElement()) === id);
+    if (!element)
+        return;
+    if (!element.getJsxChildren().every(child => child.getKind() === SyntaxKind.JsxText && child.getText().trim() === ''))
+        return;
+    const openingText = element.getOpeningElement().getText();
+    element.getSourceFile().replaceText([element.getStart(), element.getEnd()], `${openingText.slice(0, -1).trimEnd()} />`);
+}
+function removeFullNode(full) {
+    const sourceFile = full.getSourceFile();
+    const fullText = sourceFile.getFullText();
+    let start = full.getStart();
+    while (start > 0 && (fullText[start - 1] === ' ' || fullText[start - 1] === '\t'))
+        start--;
+    let end = full.getEnd();
+    while (end < fullText.length && (fullText[end] === '\n' || fullText[end] === '\r'))
+        end++;
+    sourceFile.removeText(start, end);
+}
+// Rimuove gli import dei soli identificatori usati dal ramo appena tagliato (`removedHeads`)
+// che nel file non sono più referenziati da nessuna parte. Gli altri import non si toccano.
+function pruneImportsOf(sourceFile, removedHeads) {
+    if (removedHeads.size === 0)
+        return;
+    const stillUsed = (name, decl) => sourceFile.getDescendantsOfKind(SyntaxKind.Identifier)
+        .some(id => id.getText() === name && id.getFirstAncestorByKind(SyntaxKind.ImportDeclaration) !== decl);
+    const localOf = (named) => named.getAliasNode()?.getText() ?? named.getName();
+    const count = sourceFile.getImportDeclarations().length;
+    for (let i = count - 1; i >= 0; i--) { // dall'ultimo: togliere un import intero non sposta gli indici di quelli prima
+        let decl = sourceFile.getImportDeclarations()[i];
+        let touched = false;
+        const drop = decl.getNamedImports().map(localOf).filter(local => removedHeads.has(local) && !stillUsed(local, decl));
+        for (const local of drop) {
+            // Come testo (vedi `ensureImports`): niente impaginazione rifatta dagli altri specificatori.
+            decl = sourceFile.getImportDeclarations()[i];
+            const specs = decl.getNamedImports();
+            const k = specs.findIndex(n => localOf(n) === local);
+            if (specs.length === 1)
+                specs[0].remove();
+            else if (k > 0)
+                sourceFile.removeText(specs[k - 1].getEnd(), specs[k].getEnd());
+            else
+                sourceFile.removeText(specs[0].getStart(), specs[1].getStart());
+            touched = true;
+        }
+        decl = sourceFile.getImportDeclarations()[i];
+        const defaultImport = decl.getDefaultImport();
+        if (defaultImport && removedHeads.has(defaultImport.getText()) && !stillUsed(defaultImport.getText(), decl)) {
+            decl.removeDefaultImport();
+            touched = true;
+        }
+        const nsImport = decl.getNamespaceImport();
+        if (nsImport && removedHeads.has(nsImport.getText()) && !stillUsed(nsImport.getText(), decl)) {
+            decl.removeNamespaceImport();
+            touched = true;
+        }
+        const empty = !decl.getDefaultImport() && !decl.getNamespaceImport() && decl.getNamedImports().length === 0;
+        if (touched && empty)
+            decl.remove();
+    }
+}
+export function deleteJsx(project, filePath, id, options = {}) {
+    const found = findNode(project, filePath, id);
+    if (!found)
+        return null;
+    // L'unico elemento che un componente restituisce (la radice di un header o di un footer): senza lascerebbe `return ( )`, codice non valido
+    if (findPageRoot(found.full.getSourceFile()) === found.full) {
+        return { refused: true, code: 'component-root', error: `"${id}" is the only element its component returns: remove the header or the footer of a page with the page's setting, or edit the code` };
+    }
+    // catturare TUTTO prima di mutare l'albero: testo esatto + ancora per l'undo
+    const removedIds = collectSubtreeIds(found.full);
+    const removedTagHeads = collectSubtreeTagHeads(found.full);
+    // senza il rientro del nodo sulle righe di continuazione: reinserito altrove prende quello del posto nuovo
+    const own = getIndent(found.full);
+    const removedJsx = found.full.getText().split('\n').map((line, i) => (i > 0 && line.startsWith(own) ? line.slice(own.length) : line)).join('\n');
+    const { anchor, anchorMode } = getAnchor(found.full);
+    const sourceFile = found.full.getSourceFile();
+    const parentId = idOfJsx(found.full.getParentIfKind(SyntaxKind.JsxElement)?.getOpeningElement());
+    removeFullNode(found.full);
+    if (parentId)
+        closeIfEmpty(sourceFile, parentId);
+    if (options.pruneImports !== false)
+        pruneImportsOf(sourceFile, removedTagHeads);
+    sourceFile.saveSync();
+    return { removedIds, removedJsx, anchor, anchorMode };
+}
+/**
+ * Sposta un elemento (e i suoi figli) in un altro punto dello stesso file. Gli id restano quelli: il JSON non si tocca. È una
+ * cancellazione e un inserimento dello stesso testo; se l'inserimento non riesce il file torna com'era, e la scrittura finale è una.
+ */
+export function moveJsx(project, filePath, request) {
+    const { id, anchor, mode } = request;
+    const found = findNode(project, filePath, id);
+    if (!found)
+        return fail(404, 'anchor-not-found', `no element with id "${id}"`);
+    const sourceFile = found.full.getSourceFile();
+    const original = sourceFile.getFullText();
+    if (isGeneratedByCode(found.full))
+        return fail(422, 'generated-by-code', `"${id}" is generated by code (inside {...}): it cannot be moved from the editor`);
+    if (findPageRoot(sourceFile) === found.full)
+        return fail(422, 'component-root', `"${id}" is the only element its component returns: it has nowhere to move`);
+    if ('id' in anchor) {
+        if (anchor.id === id)
+            return fail(422, 'invalid-move', 'an element cannot be moved next to or into itself');
+        const target = findNode(project, filePath, anchor.id);
+        if (target && target.full.getStart() >= found.full.getStart() && target.full.getEnd() <= found.full.getEnd()) {
+            return fail(422, 'invalid-move', `"${anchor.id}" is inside "${id}": an element cannot be moved into what it contains`);
+        }
+    }
+    const from = getAnchor(found.full);
+    if (!from.anchor)
+        return fail(422, 'generated-by-code', `"${id}" has no fixed place in the JSX to be moved back to`);
+    const removed = deleteJsx(project, filePath, id, { pruneImports: false });
+    if (!removed || 'refused' in removed)
+        return fail(422, 'component-root', removed && 'error' in removed ? removed.error : 'not found');
+    const inserted = insertJsx(project, filePath, { jsx: removed.removedJsx, anchor, mode, uniqueIds: false });
+    if (!inserted.ok) {
+        sourceFile.replaceWithText(original);
+        sourceFile.saveSync();
+        return inserted;
+    }
+    return { ok: true, id, from: { anchor: from.anchor, mode: from.anchorMode } };
+}
+// ── Attributes: the literal values the editor's panel reads and writes ────────────────
+/** The literal value of a JSX attribute: a string, a boolean, a number. `present: false` for anything the code decides (an expression). */
+export function readJsxLiteral(node, key) {
+    const attr = node.getAttribute(key);
+    if (!attr || attr.getKind() !== SyntaxKind.JsxAttribute)
+        return { present: false };
+    const init = attr.getInitializer?.();
+    if (!init)
+        return { present: true, value: true };
+    if (init.getKind() === SyntaxKind.StringLiteral)
+        return { present: true, value: init.getLiteralValue() };
+    if (init.getKind() === SyntaxKind.JsxExpression) {
+        const expr = init.getExpression();
+        if (!expr)
+            return { present: false };
+        if (expr.getKind() === SyntaxKind.TrueKeyword)
+            return { present: true, value: true };
+        if (expr.getKind() === SyntaxKind.FalseKeyword)
+            return { present: true, value: false };
+        if (expr.getKind() === SyntaxKind.NumericLiteral)
+            return { present: true, value: Number(expr.getText()) };
+        if (expr.getKind() === SyntaxKind.StringLiteral)
+            return { present: true, value: expr.getLiteralValue() };
+    }
+    return { present: false };
+}
+/** Writes (or, with null, removes) a literal attribute. */
+export function writeJsxLiteral(node, key, value) {
+    const existing = node.getAttribute(key);
+    if (value === null) {
+        if (existing && existing.getKind() === SyntaxKind.JsxAttribute)
+            existing.remove();
+        return;
+    }
+    // JSX non ha escape con backslash dentro le stringhe-attributo: se il valore contiene `"`
+    // l'unico modo sicuro è un'espressione `{"..."}` (JSON.stringify produce un literal TS valido).
+    let text;
+    if (typeof value === 'string')
+        text = value.includes('"') ? `{${JSON.stringify(value)}}` : `"${value}"`;
+    else
+        text = `{${value}}`;
+    if (existing && existing.getKind() === SyntaxKind.JsxAttribute) {
+        existing.setInitializer(text);
+    }
+    else {
+        node.addAttribute({ name: key, initializer: text });
+    }
+}
+//# sourceMappingURL=jsx-tree.js.map