@webround/editor 0.0.0-stage → 0.3.0

package/dist/vite-plugins/core-swap.d.ts

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

package/dist/vite-plugins/core-swap.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+export function wrCoreSwapPlugin() {
+    let editorPkgDir = null;
+    let editorEntry = null;
+    try {
+        editorEntry = require.resolve('@webround/editor');
+        // risali da editorEntry finche' non trovi la root del pacchetto (dove sta il suo package.json)
+        let dir = path.dirname(editorEntry);
+        while (dir !== path.dirname(dir)) {
+            if (fs.existsSync(path.join(dir, 'package.json'))) {
+                const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+                if (pkg.name === '@webround/editor') {
+                    editorPkgDir = dir;
+                    break;
+                }
+            }
+            dir = path.dirname(dir);
+        }
+    }
+    catch (err) {
+        editorPkgDir = null;
+        editorEntry = null;
+    }
+    return {
+        name: 'wr-core-swap',
+        enforce: 'pre',
+        // Pacchetto installato in node_modules (non linkato come nel monorepo): va dichiarato subito
+        // all'optimizer, altrimenti Vite lo scopre a runtime, riottimizza e ricarica la pagina al primo avvio.
+        // Se è linkato (sviluppo dell'SDK) NON va pre-bundlato: le modifiche all'editor devono restare visibili.
+        config() {
+            const installed = editorPkgDir !== null && editorPkgDir.split(path.sep).includes('node_modules');
+            return installed ? { optimizeDeps: { include: ['@webround/editor'] } } : {};
+        },
+        async resolveId(source, importer) {
+            if (!editorEntry || !editorPkgDir)
+                return null;
+            if (source !== '@webround/core')
+                return null;
+            if (importer) {
+                const normalizedImporter = path.resolve(importer);
+                const normalizedEditorDir = path.resolve(editorPkgDir);
+                if (normalizedImporter.startsWith(normalizedEditorDir + path.sep)) {
+                    return null;
+                }
+            }
+            // Si risolve il pacchetto come import "bare" invece di restituire il path assoluto:
+            // così, quando @webround/editor è installato in node_modules (non linkato come nel monorepo),
+            // Vite lo riconosce come dipendenza e lo pre-bundla insieme alle sue dipendenze (react-router, cookie, …).
+            // Con un path assoluto il pacchetto veniva servito "crudo" e le dipendenze CJS si rompevano nel browser.
+            return this.resolve('@webround/editor', importer, { skipSelf: true });
+        },
+    };
+}
+//# sourceMappingURL=core-swap.js.map

package/dist/vite-plugins/create-page.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'vite';
+export declare function wrPageScaffold(component: string): string;
+export declare function wrCreatePagePlugin(): Plugin;
+//# sourceMappingURL=create-page.d.ts.map

package/dist/vite-plugins/create-page.js

@@ -0,0 +1,59 @@
+import fs from 'fs';
+import path from 'path';
+import { SRC_ROOT, isSafePageName, isSafeComponentName, wrRoute } from './guard.js';
+export function wrPageScaffold(component) {
+    return `import { WrSection } from '@webround/core';
+
+export default function ${component}() {
+    return <WrSection id="root" />;
+}
+`;
+}
+export function wrCreatePagePlugin() {
+    return {
+        name: 'wr-create-page',
+        configureServer(server) {
+            wrRoute(server, '/wr/create-page', (req, res) => {
+                if (req.method !== 'POST') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const { pageName, component, lazy } = JSON.parse(body);
+                        if (!isSafePageName(pageName) || !isSafeComponentName(component)) {
+                            res.statusCode = 400;
+                            res.end(JSON.stringify({ error: 'invalid pageName or component' }));
+                            return;
+                        }
+                        const pagePath = path.join(SRC_ROOT, 'config', 'pages', `${pageName}.json`);
+                        const componentPath = path.join(SRC_ROOT, 'pages', `${component}.tsx`);
+                        const routesPath = path.join(SRC_ROOT, 'config', 'routes.json');
+                        if (fs.existsSync(pagePath) || fs.existsSync(componentPath)) {
+                            res.statusCode = 409;
+                            res.end(JSON.stringify({ error: 'page or component already exists' }));
+                            return;
+                        }
+                        fs.mkdirSync(path.dirname(pagePath), { recursive: true });
+                        fs.writeFileSync(pagePath, JSON.stringify({}, null, 2));
+                        fs.mkdirSync(path.dirname(componentPath), { recursive: true });
+                        fs.writeFileSync(componentPath, wrPageScaffold(component));
+                        const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                        routes[pageName] = { component, ...(lazy ? { lazy: true } : {}) };
+                        fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                    catch (err) {
+                        console.error('[wr-create-page] failed:', err);
+                        res.statusCode = 500;
+                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                    }
+                });
+            });
+        }
+    };
+}
+//# sourceMappingURL=create-page.js.map

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

@@ -0,0 +1,15 @@
+import type { Connect, ViteDevServer } from 'vite';
+import type { IncomingMessage, ServerResponse } from 'http';
+/**
+ * Accetta SOLO richieste same-origin, cioè fatte dall'app che gira nell'iframe verso sé stessa.
+ * Il browser imposta `Sec-Fetch-Site` e non è falsificabile da JS: le chiamate cross-origin
+ * (il parent wr-editor, un altro sito, un fetch da fuori) risultano `cross-site`/`same-site` e vengono rifiutate.
+ * L'assenza dell'header (client non-browser) è un rifiuto. NB: un client non-browser che forgia gli header
+ * non è fermato da qui — quello è compito dell'autenticazione davanti al container.
+ */
+export declare function isSameOriginRequest(req: IncomingMessage): boolean;
+type Handler = (req: IncomingMessage, res: ServerResponse, next: Connect.NextFunction) => void;
+/** Registra un middleware /wr/* protetto dal guard same-origin. Da usare al posto di `server.middlewares.use`. */
+export declare function wrRoute(server: ViteDevServer, route: string, handler: Handler): void;
+export {};
+//# sourceMappingURL=guard.d.ts.map

package/dist/vite-plugins/guard.js

@@ -0,0 +1,35 @@
+/**
+ * Accetta SOLO richieste same-origin, cioè fatte dall'app che gira nell'iframe verso sé stessa.
+ * Il browser imposta `Sec-Fetch-Site` e non è falsificabile da JS: le chiamate cross-origin
+ * (il parent wr-editor, un altro sito, un fetch da fuori) risultano `cross-site`/`same-site` e vengono rifiutate.
+ * L'assenza dell'header (client non-browser) è un rifiuto. NB: un client non-browser che forgia gli header
+ * non è fermato da qui — quello è compito dell'autenticazione davanti al container.
+ */
+export function isSameOriginRequest(req) {
+    if (req.headers['sec-fetch-site'] !== 'same-origin')
+        return false;
+    const origin = req.headers.origin;
+    if (origin) {
+        try {
+            if (new URL(origin).host !== req.headers.host)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+/** Registra un middleware /wr/* protetto dal guard same-origin. Da usare al posto di `server.middlewares.use`. */
+export function wrRoute(server, route, handler) {
+    server.middlewares.use(route, (req, res, next) => {
+        if (!isSameOriginRequest(req)) {
+            res.statusCode = 403;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({ error: 'forbidden' }));
+            return;
+        }
+        handler(req, res, next);
+    });
+}
+//# sourceMappingURL=guard.js.map

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

@@ -0,0 +1,13 @@
+import type { Plugin } from 'vite';
+/**
+ * What belongs in the HTML a visitor (and a crawler) gets BEFORE any script runs, because a crawler looks for it there: today the Google Search Console
+ * verification tag. It is put in `index.html` as the page is served in dev and as it is built, from `config/seo.json` (the one place it is written:
+ * the SEO panel, `seo-site-set`), so it is in the file that goes to the CDN and in every copy of it. Everything else a page says to search engines is
+ * written at runtime by `WrSeoHead`. A tag the project's own `index.html` already has is left alone: it is never written twice.
+ *
+ * The other thing that must be there before the first paint is the theme of a site that has two (a `.dark` block in `src/theme.css`): the script that sets the `dark` class
+ * on <html> from the visitor's choice (or their system's, if the theme says so) is put in the head from `theme.css`, so a dark page never flashes light and nobody has to
+ * write the script. A site with one theme gets nothing. A page that already handles the theme itself (it names the storage key) is left alone.
+ */
+export declare function wrHeadPlugin(root?: string): Plugin;
+//# sourceMappingURL=head.d.ts.map

package/dist/vite-plugins/head.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import { wrSearchConsoleCode } from '@webround/core/seo';
+import { WR_BASE_CSS } from '@webround/core/base-css';
+import { WR_THEME_STORAGE_KEY, wrThemeHasDark, wrThemeStartScript, wrThemeStartsFromSystem } from '@webround/core/theme';
+import { SEO_FILE } from '../operations/ops/project.js';
+/**
+ * What belongs in the HTML a visitor (and a crawler) gets BEFORE any script runs, because a crawler looks for it there: today the Google Search Console
+ * verification tag. It is put in `index.html` as the page is served in dev and as it is built, from `config/seo.json` (the one place it is written:
+ * the SEO panel, `seo-site-set`), so it is in the file that goes to the CDN and in every copy of it. Everything else a page says to search engines is
+ * written at runtime by `WrSeoHead`. A tag the project's own `index.html` already has is left alone: it is never written twice.
+ *
+ * The other thing that must be there before the first paint is the theme of a site that has two (a `.dark` block in `src/theme.css`): the script that sets the `dark` class
+ * on <html> from the visitor's choice (or their system's, if the theme says so) is put in the head from `theme.css`, so a dark page never flashes light and nobody has to
+ * write the script. A site with one theme gets nothing. A page that already handles the theme itself (it names the storage key) is left alone.
+ */
+export function wrHeadPlugin(root = process.cwd()) {
+    const seoFile = path.join(root, 'src', SEO_FILE);
+    const themeFile = path.join(root, 'src', 'theme.css');
+    const readTheme = () => { try {
+        return fs.readFileSync(themeFile, 'utf-8');
+    }
+    catch {
+        return '';
+    } };
+    const read = () => {
+        try {
+            return JSON.parse(fs.readFileSync(seoFile, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    };
+    return {
+        name: 'wr-head',
+        transformIndexHtml: {
+            order: 'pre',
+            handler(html) {
+                const tags = [];
+                if (!html.includes('data-wr-base'))
+                    tags.push({ tag: 'style', attrs: { 'data-wr-base': '' }, children: WR_BASE_CSS, injectTo: 'head-prepend' });
+                const code = wrSearchConsoleCode(read().searchConsole);
+                if (code && !/name\s*=\s*["']google-site-verification["']/i.test(html))
+                    tags.push({ tag: 'meta', attrs: { name: 'google-site-verification', content: code }, injectTo: 'head-prepend' });
+                const theme = readTheme();
+                if (wrThemeHasDark(theme) && !html.includes(WR_THEME_STORAGE_KEY))
+                    tags.push({ tag: 'script', children: wrThemeStartScript(wrThemeStartsFromSystem(theme)), injectTo: 'head-prepend' });
+                return tags;
+            },
+        },
+    };
+}
+//# sourceMappingURL=head.js.map

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

@@ -0,0 +1,7 @@
+export { wrOperationsPlugin } from './operations.js';
+export { wrPageScaffold } from '../operations/ops/pages.js';
+export { wrCoreSwapPlugin } from './core-swap.js';
+export { wrPagesPlugin } from './pages.js';
+export { wrLangsPlugin } from './langs.js';
+export { wrPlugins, type WrPluginsOptions } from './wr-plugins.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/vite-plugins/index.js

@@ -0,0 +1,7 @@
+export { wrOperationsPlugin } from './operations.js';
+export { wrPageScaffold } from '../operations/ops/pages.js';
+export { wrCoreSwapPlugin } from './core-swap.js';
+export { wrPagesPlugin } from './pages.js';
+export { wrLangsPlugin } from './langs.js';
+export { wrPlugins } from './wr-plugins.js';
+//# sourceMappingURL=index.js.map

package/dist/vite-plugins/jsx-tree.d.ts

@@ -0,0 +1,118 @@
+import { Project, ts, type JsxSelfClosingElement, type JsxOpeningElement, type JsxElement, type JsxFragment, type SourceFile, type Node } from 'ts-morph';
+import { type WrElementKind } from '@webround/core/kinds';
+import type { WrAnchorMode, WrAnchor } from '../messages';
+export type JsxNode = JsxSelfClosingElement | JsxOpeningElement;
+export type FullJsxNode = JsxElement | JsxSelfClosingElement;
+export declare function toFullNode(node: JsxNode): FullJsxNode;
+export declare function loadSourceFile(project: Project, filePath: string): SourceFile | undefined;
+export declare function findNode(project: Project, filePath: string, id: string): {
+    node: JsxNode;
+    full: FullJsxNode;
+    kind: WrElementKind;
+} | null;
+/** Gli id letterali di tutti i componenti Wr* di un file. */
+export declare function collectFileIds(sourceFile: SourceFile): Set<string>;
+export declare function getIndent(node: Node): string;
+/**
+ * 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 declare function ensureImports(sourceFile: SourceFile, names: string[]): void;
+type PageRoot = JsxElement | JsxFragment | JsxSelfClosingElement;
+/**
+ * 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 declare function findPageRoot(sourceFile: SourceFile): PageRoot | null;
+export type InsertErrorCode = 'invalid-jsx' | 'id-exists' | 'anchor-not-found' | 'generated-by-code' | 'component-root' | 'invalid-move' | 'not-a-container' | 'invalid-mode' | 'no-page-root' | 'invalid-result';
+export interface InsertError {
+    ok: false;
+    status: number;
+    code: InsertErrorCode;
+    error: string;
+}
+export interface InsertRequest {
+    /** Markup JSX: uno o più elementi, qualunque tag: l'editor non impone una struttura. I componenti Wr* possono non avere `id`: se manca (o è già preso) lo sceglie il plugin. */
+    jsx: string;
+    anchor: WrAnchor;
+    mode: WrAnchorMode;
+    /** Un id già preso viene cambiato (`hero` → `hero-2`) invece di rifiutare l'inserimento. Predefinito: true. */
+    uniqueIds?: boolean;
+}
+export interface InsertSuccess {
+    ok: true;
+    /** Gli id di tutti i componenti Wr* inseriti, nell'ordine del documento, come sono finiti nel file. */
+    ids: string[];
+    /** Gli id degli elementi di primo livello che sono componenti Wr*: sono quelli che un annulla rimuove. */
+    rootIds: string[];
+    /** Vero se ogni elemento di primo livello è un componente Wr* (ha un id): solo allora l'inserimento si può annullare per id. */
+    undoable: boolean;
+    /** `idRichiesto → idFinale`, solo per quelli cambiati. */
+    idMap: Record<string, string>;
+    /** Il markup così com'è stato inserito (id finali, senza indentazione di contesto): per rifare l'inserimento. */
+    jsx: string;
+}
+/** What the parser could not read: the message and the line of each problem (an unclosed tag, a stray token…). */
+export declare function syntaxErrors(sf: ts.SourceFile): {
+    message: string;
+    line: number;
+}[];
+/** L'unità di indentazione del file: tab, o il rientro più piccolo che vi compare (2 o 4 spazi di solito). */
+export declare function detectIndentUnit(text: string): string;
+/**
+ * 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 declare function reindent(text: string, unit: string): string;
+/**
+ * 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 declare function insertJsx(project: Project, filePath: string, request: InsertRequest): InsertSuccess | InsertError;
+export interface DeleteResult {
+    removedIds: string[];
+    removedJsx: string;
+    anchor: WrAnchor | null;
+    anchorMode: WrAnchorMode;
+}
+/** Toglie il nodo con questo id (e i suoi discendenti) dal file, ripulendo gli import che non servono più. null se non c'è. */
+/** Non si cancella: nessun cambiamento, e il perché. */
+export interface DeleteRefused {
+    refused: true;
+    code: 'component-root';
+    error: string;
+}
+export declare function deleteJsx(project: Project, filePath: string, id: string, options?: {
+    pruneImports?: boolean;
+}): DeleteResult | DeleteRefused | null;
+export interface MoveRequest {
+    /** L'elemento da spostare, con tutto ciò che contiene. */
+    id: string;
+    /** Dove va, rispetto a un altro elemento (o alla radice della pagina), come per un inserimento. */
+    anchor: WrAnchor;
+    mode: WrAnchorMode;
+}
+export interface MoveSuccess {
+    ok: true;
+    id: string;
+    /** Dov'era: per annullare basta spostarlo di nuovo lì. */
+    from: {
+        anchor: WrAnchor;
+        mode: WrAnchorMode;
+    };
+}
+/**
+ * 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 declare function moveJsx(project: Project, filePath: string, request: MoveRequest): MoveSuccess | InsertError;
+/** The literal value of a JSX attribute: a string, a boolean, a number. `present: false` for anything the code decides (an expression). */
+export declare function readJsxLiteral(node: JsxNode, key: string): {
+    present: boolean;
+    value?: string | boolean | number;
+};
+/** Writes (or, with null, removes) a literal attribute. */
+export declare function writeJsxLiteral(node: JsxNode, key: string, value: string | boolean | number | null): void;
+export {};
+//# sourceMappingURL=jsx-tree.d.ts.map