@webround/editor 0.0.0-stage → 0.3.0

package/dist/save.d.ts

@@ -0,0 +1,65 @@
+import type { WrLangConfig } from '@webround/core/routing';
+import type { Issue } from './check/types';
+import type { WrCommentAddRequest, WrCommentsResponse, WrJsonPruneResponse, WrSeoGetResponse, WrSeoSuggestResponse, WrSeoSetRequest, WrSeoSiteSetRequest, WrThemeItem } from './messages';
+export interface WrOpResult<T = any> {
+    ok: boolean;
+    /** The HTTP status, 0 when the dev server could not be reached. */
+    status: number;
+    data?: T;
+    /** Why not: a code a caller can act on, and the words. */
+    code?: string;
+    error?: string;
+}
+export declare function wrOp<T = any>(name: string, input?: object): Promise<WrOpResult<T>>;
+export declare function wrSaveFile(file: string, patch: Record<string, unknown>): Promise<void>;
+export declare function wrSavePage(pageName: string, id: string, value: unknown): Promise<void>;
+export declare function wrSaveRoutes(patch: Record<string, unknown>): Promise<void>;
+export declare const wrCreatePage: (pageName: string, component: string, lazy?: boolean) => Promise<WrOpResult<any>>;
+export interface WrPageEntry {
+    pageName: string;
+    component: string;
+    lazy?: boolean;
+    header: boolean;
+    footer: boolean;
+}
+export declare const wrListPages: () => Promise<WrOpResult<{
+    pages: WrPageEntry[];
+}>>;
+export declare const wrDeletePage: (pageName: string) => Promise<WrOpResult<any>>;
+export declare const wrUpdatePage: (pageName: string, patch: {
+    newPageName?: string;
+    newComponent?: string;
+    lazy?: boolean;
+    header?: boolean;
+    footer?: boolean;
+}) => Promise<WrOpResult<any>>;
+export declare function wrListLangs(): Promise<WrLangConfig | null>;
+export declare const wrSaveLangs: (langs: WrLangConfig) => Promise<WrOpResult<any>>;
+export declare function wrGetSeo(pageName?: string): Promise<WrSeoGetResponse>;
+export declare function wrSuggestSeo(pageName: string, lang?: string): Promise<WrSeoSuggestResponse>;
+/** Everything `wr-check` finds in the project (the editor's notifications). */
+export declare function wrCheckProject(): Promise<{
+    issues: Issue[];
+    muted: string[];
+    error?: string;
+}>;
+/** Silence a problem the person chose not to deal with (or bring it back). */
+export declare const wrMuteIssue: (key: string, muted: boolean) => Promise<WrOpResult<any>>;
+/** Remove the values of elements that are no longer in the code. */
+export declare function wrPruneJson(page?: string): Promise<WrJsonPruneResponse>;
+/** The comments of the site (open and resolved), and how many are open. */
+export declare function wrGetComments(): Promise<WrCommentsResponse>;
+/** What the editor's page does with a comment: the author is always a person (the editor says who). */
+export declare const wrAddComment: ({ page, elementId, text, authorName }: WrCommentAddRequest) => Promise<WrOpResult<any>>;
+export declare const wrResolveComment: (id: string, resolved: boolean) => Promise<WrOpResult<any>>;
+export declare const wrDeleteComment: (id: string) => Promise<WrOpResult<any>>;
+export declare const wrSetSeo: ({ pageName, ...fields }: WrSeoSetRequest) => Promise<WrOpResult<any>>;
+export declare const wrSetSeoSite: (fields: WrSeoSiteSetRequest) => Promise<WrOpResult<any>>;
+export declare function wrGetTheme(): Promise<{
+    items: WrThemeItem[];
+    dark: boolean;
+}>;
+export declare const wrSetThemeDark: (enabled: boolean) => Promise<WrOpResult<any>>;
+export declare const wrSetThemeItem: (item: WrThemeItem) => Promise<WrOpResult<any>>;
+export declare const wrRemoveThemeItem: (kind: WrThemeItem["kind"], key: string) => Promise<WrOpResult<any>>;
+//# sourceMappingURL=save.d.ts.map

package/dist/save.js

@@ -0,0 +1,86 @@
+export async function wrOp(name, input = {}) {
+    try {
+        const res = await fetch(`/wr/op/${name}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(input),
+        });
+        const body = await res.json().catch(() => null);
+        if (res.ok && body?.ok)
+            return { ok: true, status: res.status, data: body.data };
+        return { ok: false, status: res.status, code: body?.code, error: body?.error ?? `HTTP ${res.status}` };
+    }
+    catch (err) {
+        return { ok: false, status: 0, error: String(err) };
+    }
+}
+/** The data of an operation that has to work: otherwise it throws what went wrong. */
+async function must(name, input) {
+    const result = await wrOp(name, input);
+    if (!result.ok) {
+        console.error(`[wr] ${name} failed:`, result.status, result.error);
+        throw new Error(result.error ?? `HTTP ${result.status}`);
+    }
+    return result.data;
+}
+export async function wrSaveFile(file, patch) {
+    await must('json-patch', { file, patch });
+}
+export async function wrSavePage(pageName, id, value) {
+    return wrSaveFile(`config/pages/${pageName}.json`, { [id]: value });
+}
+export async function wrSaveRoutes(patch) {
+    return wrSaveFile('config/routes.json', patch);
+}
+export const wrCreatePage = (pageName, component, lazy = false) => wrOp('page-create', { pageName, component, lazy });
+export const wrListPages = () => wrOp('page-list');
+export const wrDeletePage = (pageName) => wrOp('page-delete', { pageName });
+export const wrUpdatePage = (pageName, patch) => wrOp('page-update', { pageName, ...patch });
+export async function wrListLangs() {
+    const result = await wrOp('langs-get');
+    return result.ok ? result.data?.langs ?? null : null;
+}
+export const wrSaveLangs = (langs) => wrOp('langs-set', { default: langs.default, available: langs.available });
+export async function wrGetSeo(pageName) {
+    const result = await wrOp('seo-get', pageName ? { page: pageName } : {});
+    if (!result.ok || !result.data)
+        return { site: {}, siteUrlKnown: false, error: result.error ?? `HTTP ${result.status}` };
+    return result.data;
+}
+export async function wrSuggestSeo(pageName, lang) {
+    const result = await wrOp('seo-suggest', { page: pageName, ...(lang ? { lang } : {}) });
+    if (!result.ok || !result.data)
+        return { pageName, lang: lang ?? 'default', error: result.error ?? `HTTP ${result.status}` };
+    return result.data;
+}
+/** Everything `wr-check` finds in the project (the editor's notifications). */
+export async function wrCheckProject() {
+    const result = await wrOp('project-check');
+    return result.ok && result.data ? { issues: result.data.issues, muted: result.data.muted } : { issues: [], muted: [], error: result.error ?? `HTTP ${result.status}` };
+}
+/** Silence a problem the person chose not to deal with (or bring it back). */
+export const wrMuteIssue = (key, muted) => wrOp('issue-mute', { key, muted });
+/** Remove the values of elements that are no longer in the code. */
+export async function wrPruneJson(page) {
+    const result = await wrOp('json-prune', page ? { page } : {});
+    return result.ok && result.data ? { removed: result.data.removed } : { removed: [], error: result.error ?? `HTTP ${result.status}`, code: result.code };
+}
+/** The comments of the site (open and resolved), and how many are open. */
+export async function wrGetComments() {
+    const result = await wrOp('comment-list', { status: 'all' });
+    return result.ok && result.data ? result.data : { comments: [], open: 0, error: result.error ?? `HTTP ${result.status}` };
+}
+/** What the editor's page does with a comment: the author is always a person (the editor says who). */
+export const wrAddComment = ({ page, elementId, text, authorName }) => wrOp('comment-add', { page, ...(elementId ? { id: elementId } : {}), text, author: { name: authorName, kind: 'user' } });
+export const wrResolveComment = (id, resolved) => wrOp('comment-resolve', { comment: id, resolved });
+export const wrDeleteComment = (id) => wrOp('comment-delete', { comment: id });
+export const wrSetSeo = ({ pageName, ...fields }) => wrOp('seo-set', { page: pageName, ...fields });
+export const wrSetSeoSite = (fields) => wrOp('seo-site-set', { ...fields });
+export async function wrGetTheme() {
+    const result = await wrOp('theme-get');
+    return result.ok ? { items: result.data?.items ?? [], dark: result.data?.dark === true } : { items: [], dark: false };
+}
+export const wrSetThemeDark = (enabled) => wrOp('theme-dark', { enabled });
+export const wrSetThemeItem = (item) => wrOp('theme-set', { item });
+export const wrRemoveThemeItem = (kind, key) => wrOp('theme-remove', { kind, key });
+//# sourceMappingURL=save.js.map

package/dist/schema.d.ts

@@ -0,0 +1,69 @@
+import type { WrElementKind, WrEditorInbound } from '@webround/editor/messages';
+import { type WrFormMessage } from '@webround/core/form';
+export type FieldLabelKey = 'content' | 'label' | 'href' | 'imageUrl' | 'videoUrl' | 'iframeUrl' | 'alt' | 'title' | 'allowFullscreen' | 'loading' | 'ariaLabel' | 'hidden' | 'displayMode' | 'target' | 'autoplay' | 'loop' | 'controls' | 'items' | 'themeToggle' | 'accountMenu' | 'cartMenu' | 'placeholder' | 'inputType' | 'required' | 'maxLength' | `msg-${WrFormMessage}`;
+export type FieldBackend = 'json' | 'ast';
+/**
+ * `multilang`: the value is translated, stored as `{ default, en… }` (see `wrLocalized` / `wrSetLocalized` in @webround/core): the
+ * ONE place that says which fields are, for the panel, the page's components and every operation that writes a value.
+ */
+type BaseField = {
+    key: string;
+    labelKey: FieldLabelKey;
+    backend: FieldBackend;
+    multilang?: boolean;
+};
+export type TextareaField = BaseField & {
+    type: 'textarea';
+    rows?: number;
+};
+export type UrlField = BaseField & {
+    type: 'url';
+};
+/** A URL that comes from the media library (or is typed): `assetKind` says which library the picker opens. */
+export type AssetField = BaseField & {
+    type: 'asset';
+    assetKind: 'image' | 'video';
+};
+export type TextField = BaseField & {
+    type: 'text';
+};
+export type ToggleField = BaseField & {
+    type: 'toggle';
+};
+export type NumberField = BaseField & {
+    type: 'number';
+    min?: number;
+};
+export type SelectField = BaseField & {
+    type: 'select';
+    options: readonly string[];
+};
+/** A field of an entry of a list; `multilang` as for a field: the entry holds `{ default, en… }`. */
+export type ListItemFieldDef = {
+    key: string;
+    labelKey: FieldLabelKey;
+    type: 'text' | 'url';
+    multilang?: boolean;
+};
+export type ListField = BaseField & {
+    type: 'list';
+    itemFields: ListItemFieldDef[];
+};
+export type FieldDef = TextareaField | UrlField | AssetField | TextField | ToggleField | NumberField | SelectField | ListField;
+export interface FieldInputProps<F extends FieldDef> {
+    field: F;
+    draft: string;
+    setDraft: (v: string) => void;
+    onKeyDown: (e: React.KeyboardEvent) => void;
+}
+export declare function getFields(kind: WrElementKind): FieldDef[];
+/** Every field an element has, the ones edited on the page too (a text's content): what an operation can set. */
+export declare function getAllFields(kind: WrElementKind): FieldDef[];
+/** The fields of an element that are translated. */
+export declare const multilangFieldsOf: (kind: WrElementKind) => string[];
+export declare function buildUpdateMessage(kind: WrElementKind, elementId: string, key: string, value: string): WrEditorInbound | null;
+export declare function getFieldBackend(kind: WrElementKind, key: string): FieldBackend | null;
+/** The kind of element an update message is for (`wr:button:update` → button). */
+export declare function kindOfUpdateMessage(type: WrEditorInbound['type']): WrElementKind | undefined;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -0,0 +1,110 @@
+import { WR_FORM_MESSAGE_CODES, WR_INPUT_TYPES } from '@webround/core/form';
+// Campi comuni a ogni kind. hidden/ariaLabel restano json
+// Esigenza di accessibilità che può variare per lingua (es. aria-label tradotto).
+// Hidden per breakpoint
+const COMMON_FIELDS = [
+    { key: 'ariaLabel', labelKey: 'ariaLabel', type: 'text', backend: 'json', multilang: true },
+    { key: 'hidden', labelKey: 'hidden', type: 'toggle', backend: 'json' },
+];
+const TYPE_FIELDS = {
+    button: [
+        { key: 'content', labelKey: 'label', type: 'textarea', rows: 2, backend: 'json', multilang: true },
+    ],
+    link: [
+        { key: 'content', labelKey: 'label', type: 'textarea', rows: 2, backend: 'json', multilang: true },
+        { key: 'href', labelKey: 'href', type: 'url', backend: 'ast' },
+        { key: 'target', labelKey: 'target', type: 'select', options: ['_self', '_blank'], backend: 'ast' },
+    ],
+    image: [
+        { key: 'src', labelKey: 'imageUrl', type: 'asset', assetKind: 'image', backend: 'ast' },
+        { key: 'alt', labelKey: 'alt', type: 'text', backend: 'json', multilang: true },
+        { key: 'objectFit', labelKey: 'displayMode', type: 'select', options: ['cover', 'contain', 'fill', 'none'], backend: 'ast' },
+    ],
+    video: [
+        { key: 'src', labelKey: 'videoUrl', type: 'asset', assetKind: 'video', backend: 'ast' },
+        { key: 'autoPlay', labelKey: 'autoplay', type: 'toggle', backend: 'ast' },
+        { key: 'loop', labelKey: 'loop', type: 'toggle', backend: 'ast' },
+        { key: 'controls', labelKey: 'controls', type: 'toggle', backend: 'ast' },
+    ],
+    iframe: [
+        { key: 'src', labelKey: 'iframeUrl', type: 'url', backend: 'ast' },
+        { key: 'title', labelKey: 'title', type: 'text', backend: 'ast' },
+        { key: 'allowFullScreen', labelKey: 'allowFullscreen', type: 'toggle', backend: 'ast' },
+        { key: 'loading', labelKey: 'loading', type: 'select', options: ['lazy', 'eager'], backend: 'ast' },
+    ],
+    // Which kind of field it is and what it asks live in the code; the texts a visitor reads (label, placeholder, the form's messages) are translated, so JSON
+    input: [
+        { key: 'label', labelKey: 'label', type: 'text', backend: 'json', multilang: true },
+        { key: 'placeholder', labelKey: 'placeholder', type: 'text', backend: 'json', multilang: true },
+        { key: 'type', labelKey: 'inputType', type: 'select', options: WR_INPUT_TYPES, backend: 'ast' },
+        { key: 'required', labelKey: 'required', type: 'toggle', backend: 'ast' },
+        { key: 'maxLength', labelKey: 'maxLength', type: 'number', min: 1, backend: 'ast' },
+    ],
+    form: WR_FORM_MESSAGE_CODES.map((code) => ({ key: `msg-${code}`, labelKey: `msg-${code}`, type: 'text', backend: 'json', multilang: true })),
+    nav: [
+        {
+            key: 'items', labelKey: 'items', type: 'list', backend: 'json', // struttura + label tradotte: resta json
+            itemFields: [
+                { key: 'label', labelKey: 'label', type: 'text', multilang: true },
+                { key: 'href', labelKey: 'href', type: 'url' },
+            ],
+        },
+        // The button that switches the site between its themes: a boolean in the code (it shows only if the site has a dark theme: that is the Theme panel's)
+        { key: 'themeToggle', labelKey: 'themeToggle', type: 'toggle', backend: 'ast' },
+        // The visitor's account in the header (an icon with a sign-in, or its shortcuts): a boolean in the code; the site draws it
+        { key: 'accountMenu', labelKey: 'accountMenu', type: 'toggle', backend: 'ast' },
+        // The visitor's cart in the header (an icon with how many things are in it): a boolean in the code; the site draws it
+        { key: 'cartMenu', labelKey: 'cartMenu', type: 'toggle', backend: 'ast' },
+    ],
+};
+// Fields edited on the page itself, not in the panel (a text is written in place): not in `getFields`, but an element has them all the same
+const INLINE_FIELDS = {
+    text: [{ key: 'content', labelKey: 'content', type: 'textarea', backend: 'json', multilang: true }],
+};
+// Kind che non hanno i campi comuni (ariaLabel/hidden): nav ha i suoi.
+const NO_COMMON_FIELDS = new Set(['nav']);
+export function getFields(kind) {
+    const specific = TYPE_FIELDS[kind];
+    if (!specific)
+        return [];
+    if (NO_COMMON_FIELDS.has(kind))
+        return specific;
+    return [...specific, ...COMMON_FIELDS];
+}
+/** Every field an element has, the ones edited on the page too (a text's content): what an operation can set. */
+export function getAllFields(kind) {
+    return [...getFields(kind), ...(INLINE_FIELDS[kind] ?? [])];
+}
+/** The fields of an element that are translated. */
+export const multilangFieldsOf = (kind) => getAllFields(kind).filter(f => f.multilang).map(f => f.key);
+const UPDATE_MESSAGE_TYPE = {
+    button: 'wr:button:update',
+    link: 'wr:link:update',
+    image: 'wr:image:update',
+    video: 'wr:video:update',
+    iframe: 'wr:iframe:update',
+    nav: 'wr:nav:update',
+    input: 'wr:input:update',
+    form: 'wr:form:update',
+};
+const BOOLEAN_FIELDS = new Set(['hidden', 'autoplay', 'loop', 'controls', 'required']);
+const JSON_FIELDS_VALUE = new Set(['items']);
+export function buildUpdateMessage(kind, elementId, key, value) {
+    const type = UPDATE_MESSAGE_TYPE[kind];
+    if (!type)
+        return null;
+    let resolvedValue = value;
+    if (BOOLEAN_FIELDS.has(key))
+        resolvedValue = value === 'true';
+    else if (JSON_FIELDS_VALUE.has(key))
+        resolvedValue = JSON.parse(value);
+    return { type, elementId, [key]: resolvedValue };
+}
+export function getFieldBackend(kind, key) {
+    return getAllFields(kind).find(f => f.key === key)?.backend ?? null;
+}
+/** The kind of element an update message is for (`wr:button:update` → button). */
+export function kindOfUpdateMessage(type) {
+    return Object.keys(UPDATE_MESSAGE_TYPE).find(kind => UPDATE_MESSAGE_TYPE[kind] === type);
+}
+//# sourceMappingURL=schema.js.map

package/dist/scope.d.ts

@@ -0,0 +1,41 @@
+export interface WrScope {
+    /** Relativo a `src/`, come lo vogliono gli endpoint /wr/*. */
+    file: string;
+    /** Nome del JSON in config/pages/ (può avere sottocartelle). */
+    name: string;
+}
+export declare const WR_SCOPE_NAME_ATTR = "data-wr-scope";
+export declare const WR_SCOPE_FILE_ATTR = "data-wr-file";
+/** Da mettere sul wrapper (`display: contents`) di un ambito che non è la pagina. */
+export declare const wrScopeProps: (scope: WrScope) => {
+    readonly "data-wr-scope": string;
+    readonly "data-wr-file": string;
+};
+export declare function setPageScope(scope: WrScope): void;
+export declare const getPageScope: () => WrScope | null;
+/** L'ambito che avvolge `el`, o quello della pagina. */
+export declare function scopeOfElement(el: Element | null): WrScope | null;
+/** L'ambito dell'elemento con questo id nella pagina (quello della pagina se non c'è). */
+export declare function scopeOfId(id: string): WrScope | null;
+/** L'ambito di un'ancora: il suo elemento, o la pagina (la radice è sempre della pagina). */
+export declare const scopeOfAnchor: (anchor: {
+    id: string;
+} | {
+    root: true;
+}) => WrScope | null;
+/**
+ * Where "after the header" or "before the footer" really is. The header and the footer are one element each (the root of their
+ * component): nothing can be put next to it in their file, but what a person means is the edge of the page: the first element after
+ * the header, the last one before the footer. Everything else is left as it was said.
+ */
+export declare function pageEdgeOf<A extends {
+    id: string;
+} | {
+    root: true;
+}, M extends string>(anchor: A, mode: M): {
+    anchor: A | {
+        root: true;
+    };
+    mode: M | 'first-child' | 'last-child';
+};
+//# sourceMappingURL=scope.d.ts.map

package/dist/scope.js

@@ -0,0 +1,44 @@
+// L'ambito di un elemento: il FILE di codice che lo contiene e il nome del JSON dei suoi contenuti.
+//
+// Una pagina è il suo file e il suo JSON; header e footer sono di tutte le pagine e hanno i propri (layout/Header.tsx,
+// config/pages/_shared/header.json). Un elemento sa a quale ambito appartiene: chi lo avvolge porta due attributi (`wrScopeProps`) e il
+// bridge li legge risalendo dall'elemento. Un elemento fuori da ogni wrapper è della pagina. Così non esiste un "file attivo" unico
+// e nessun componente Wr* deve conoscere gli ambiti.
+export const WR_SCOPE_NAME_ATTR = 'data-wr-scope';
+export const WR_SCOPE_FILE_ATTR = 'data-wr-file';
+/** Da mettere sul wrapper (`display: contents`) di un ambito che non è la pagina. */
+export const wrScopeProps = (scope) => ({ [WR_SCOPE_NAME_ATTR]: scope.name, [WR_SCOPE_FILE_ATTR]: scope.file });
+let pageScope = null;
+export function setPageScope(scope) { pageScope = scope; }
+export const getPageScope = () => pageScope;
+/** L'ambito che avvolge `el`, o quello della pagina. */
+export function scopeOfElement(el) {
+    const wrapper = el?.closest(`[${WR_SCOPE_NAME_ATTR}]`);
+    if (!wrapper)
+        return pageScope;
+    return { name: wrapper.getAttribute(WR_SCOPE_NAME_ATTR), file: wrapper.getAttribute(WR_SCOPE_FILE_ATTR) };
+}
+/** L'ambito dell'elemento con questo id nella pagina (quello della pagina se non c'è). */
+export function scopeOfId(id) {
+    return scopeOfElement(document.querySelector(`[data-wr-id="${CSS.escape(id)}"]`));
+}
+/** L'ambito di un'ancora: il suo elemento, o la pagina (la radice è sempre della pagina). */
+export const scopeOfAnchor = (anchor) => 'id' in anchor ? scopeOfId(anchor.id) : pageScope;
+/**
+ * Where "after the header" or "before the footer" really is. The header and the footer are one element each (the root of their
+ * component): nothing can be put next to it in their file, but what a person means is the edge of the page: the first element after
+ * the header, the last one before the footer. Everything else is left as it was said.
+ */
+export function pageEdgeOf(anchor, mode) {
+    if (!('id' in anchor))
+        return { anchor, mode };
+    const el = document.querySelector(`[data-wr-id="${CSS.escape(anchor.id)}"]`);
+    const wrapper = el?.parentElement;
+    const shared = wrapper?.getAttribute(WR_SCOPE_NAME_ATTR);
+    if (shared === '_shared/header' && mode === 'after')
+        return { anchor: { root: true }, mode: 'first-child' };
+    if (shared === '_shared/footer' && mode === 'before')
+        return { anchor: { root: true }, mode: 'last-child' };
+    return { anchor, mode };
+}
+//# sourceMappingURL=scope.js.map

package/dist/vite-plugins/ast.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function wrAstPlugin(): Plugin;
+//# sourceMappingURL=ast.d.ts.map

package/dist/vite-plugins/ast.js

@@ -0,0 +1,238 @@
+import fs from 'fs';
+import path from 'path';
+import { Project, SyntaxKind, } from 'ts-morph';
+import { getFields } from '@webround/editor/schema';
+import { resolveInSrc, wrRoute } from './guard.js';
+import { deleteJsx, findNode, insertJsx, moveJsx, } from './jsx-tree.js';
+const ROOT = process.cwd();
+function readLiteral(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 };
+}
+function writeLiteral(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 });
+    }
+}
+const ANCHOR_MODES = ['before', 'after', 'first-child', 'last-child'];
+export function wrAstPlugin() {
+    const project = new Project({ tsConfigFilePath: path.resolve(ROOT, 'tsconfig.json'), skipAddingFilesFromTsConfig: true });
+    return {
+        name: 'wr-ast-plugin',
+        configureServer(server) {
+            wrRoute(server, '/wr/node', (req, res, next) => {
+                const url = new URL(req.url ?? '', 'http://localhost');
+                const file = url.searchParams.get('file');
+                const id = url.searchParams.get('id');
+                if (req.method === 'GET') {
+                    if (!file || !id) {
+                        res.statusCode = 400;
+                        res.end('missing file/id');
+                        return;
+                    }
+                    const resolved = resolveInSrc(file);
+                    if (!resolved || !fs.existsSync(resolved)) {
+                        res.statusCode = 404;
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const found = findNode(project, resolved, id);
+                    if (!found) {
+                        res.statusCode = 404;
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const fields = getFields(found.kind).filter(f => f.backend === 'ast');
+                    const values = {};
+                    for (const f of fields) {
+                        const { present, value } = readLiteral(found.node, f.key);
+                        if (present && value !== undefined)
+                            values[f.key] = value;
+                    }
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ fields: fields.map(f => f.key), values }));
+                    return;
+                }
+                if (req.method === 'PUT') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const { file: bodyFile, id: bodyId, key, value } = JSON.parse(body);
+                            const resolved = resolveInSrc(bodyFile);
+                            if (!resolved) {
+                                res.statusCode = 400;
+                                res.end(JSON.stringify({ error: 'invalid file' }));
+                                return;
+                            }
+                            const found = findNode(project, resolved, bodyId);
+                            if (!found) {
+                                res.statusCode = 404;
+                                res.end(JSON.stringify({ error: 'node not found' }));
+                                return;
+                            }
+                            writeLiteral(found.node, key, value);
+                            found.node.getSourceFile().saveSync();
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify({ ok: true }));
+                        }
+                        catch (err) {
+                            res.statusCode = 500;
+                            res.end(JSON.stringify({ error: String(err) }));
+                        }
+                    });
+                    return;
+                }
+                if (req.method === 'DELETE') {
+                    if (!file || !id) {
+                        res.statusCode = 400;
+                        res.end('missing file/id');
+                        return;
+                    }
+                    const resolved = resolveInSrc(file);
+                    if (!resolved) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'invalid file' }));
+                        return;
+                    }
+                    const removed = deleteJsx(project, resolved, id);
+                    if (!removed) {
+                        res.statusCode = 404;
+                        res.end(JSON.stringify({ error: 'node not found' }));
+                        return;
+                    }
+                    if ('refused' in removed) {
+                        res.statusCode = 422;
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify({ ok: false, code: removed.code, error: removed.error }));
+                        return;
+                    }
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ ok: true, ...removed }));
+                    return;
+                }
+                if (req.method === 'PATCH') {
+                    // Spostare un elemento (con ciò che contiene) in un altro punto dello stesso file
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        const send = (status, payload) => {
+                            res.statusCode = status;
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify(payload));
+                        };
+                        try {
+                            const { file: bodyFile, id: moveId, anchor, anchorMode } = JSON.parse(body);
+                            const resolved = resolveInSrc(bodyFile);
+                            if (!resolved) {
+                                send(400, { error: 'invalid file' });
+                                return;
+                            }
+                            if (typeof moveId !== 'string' || !moveId) {
+                                send(400, { code: 'anchor-not-found', error: 'id required' });
+                                return;
+                            }
+                            if (!anchor || typeof anchor !== 'object' || !('root' in anchor ? anchor.root === true : typeof anchor.id === 'string')) {
+                                send(400, { code: 'anchor-not-found', error: 'anchor required: { id } or { root: true }' });
+                                return;
+                            }
+                            if (!ANCHOR_MODES.includes(anchorMode)) {
+                                send(400, { code: 'invalid-mode', error: 'anchorMode required' });
+                                return;
+                            }
+                            const result = moveJsx(project, resolved, { id: moveId, anchor, mode: anchorMode });
+                            if (!result.ok) {
+                                send(result.status, { code: result.code, error: result.error });
+                                return;
+                            }
+                            send(200, { ok: true, id: result.id, from: result.from });
+                        }
+                        catch (err) {
+                            send(500, { error: String(err) });
+                        }
+                    });
+                    return;
+                }
+                if (req.method === 'POST') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        const send = (status, payload) => {
+                            res.statusCode = status;
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify(payload));
+                        };
+                        try {
+                            // Il contratto è codice: JSX in ingresso, lo stesso per l'editor, per chi scrive a mano e per un'AI.
+                            // `afterId` è il vecchio nome di `anchor.id`.
+                            const { file: bodyFile, anchor, afterId, anchorMode, rawJsx, uniqueIds } = JSON.parse(body);
+                            const resolved = resolveInSrc(bodyFile);
+                            if (!resolved) {
+                                send(400, { error: 'invalid file' });
+                                return;
+                            }
+                            if (typeof rawJsx !== 'string' || !rawJsx.trim()) {
+                                send(400, { code: 'invalid-jsx', error: 'rawJsx required' });
+                                return;
+                            }
+                            const target = anchor && typeof anchor === 'object' ? anchor : typeof afterId === 'string' ? { id: afterId } : null;
+                            if (!target || !('root' in target ? target.root === true : typeof target.id === 'string')) {
+                                send(400, { code: 'anchor-not-found', error: 'anchor required: { id } or { root: true }' });
+                                return;
+                            }
+                            const mode = ANCHOR_MODES.includes(anchorMode) ? anchorMode : 'after';
+                            const result = insertJsx(project, resolved, { jsx: rawJsx, anchor: target, mode, uniqueIds });
+                            if (!result.ok) {
+                                send(result.status, { code: result.code, error: result.error });
+                                return;
+                            }
+                            send(200, { ok: true, ids: result.ids, rootIds: result.rootIds, undoable: result.undoable, idMap: result.idMap, jsx: result.jsx });
+                        }
+                        catch (err) {
+                            send(500, { error: String(err) });
+                        }
+                    });
+                    return;
+                }
+                next();
+            });
+        },
+    };
+}
+//# sourceMappingURL=ast.js.map