@webround/editor 0.0.0-stage → 0.3.0

package/dist/operations/ops/comments.js

@@ -0,0 +1,133 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import { findNode, readJsxLiteral } from '../../vite-plugins/jsx-tree.js';
+import { idsInCode } from '../../check/orphans.js';
+import { defineOperation, invalid, object, OperationError, requiredText, text } from '../define.js';
+import { COMMENT_TEXT_MAX, COMMENTS_MAX, readComments, writeComments } from '../comments-store.js';
+import { readJsonFile, scopeOfInput } from './project.js';
+// What is said about the elements of a site: add a comment to an element (or to a page), list them, mark one as dealt with, delete one. The
+// comments are in `.wr/comments.json` and never reach the published site (see comments-store.ts). An agent starts its work with
+// `comment-list`: what is open is what the people who work on the site asked for.
+const SCOPE_PARAMS = [
+    { name: 'page', type: 'string', help: 'the page (its name, e.g. home) or a shared component (_shared/header, _shared/footer, _shared/<name>)' },
+    { name: 'file', type: 'string', help: 'instead of page: the code file, relative to src/ (what the editor\'s own page sends)' },
+];
+const EXCERPT_MAX = 80;
+/** The kind of the element and the start of what it says, kept with the comment. */
+function contextOf(ctx, scope, id) {
+    const file = ctx.resolveInSrc(scope.file);
+    if (!fs.existsSync(file))
+        throw new OperationError(404, 'file-not-found', `${scope.file} does not exist`);
+    const found = findNode(ctx.project(), file, id);
+    if (!found)
+        throw new OperationError(404, 'node-not-found', `no element with id "${id}" in ${scope.file}`);
+    const own = (readJsonFile(ctx, scope.json) ?? {})[id];
+    const content = own?.content;
+    const fromJson = typeof content === 'string' ? content : typeof content?.default === 'string' ? content.default : undefined;
+    const literal = (key) => { const r = readJsxLiteral(found.node, key); return r.present && typeof r.value === 'string' ? r.value : undefined; };
+    const raw = fromJson ?? literal('html') ?? literal('alt') ?? literal('src');
+    const excerpt = raw?.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, EXCERPT_MAX);
+    return { kind: found.kind, ...(excerpt ? { excerpt } : {}) };
+}
+function authorOf(input) {
+    const given = object(input, 'author');
+    const name = typeof given?.name === 'string' && given.name.trim() ? given.name.trim().slice(0, 80) : undefined;
+    const kind = given?.kind;
+    if (kind !== undefined && kind !== 'user' && kind !== 'ai')
+        throw invalid('author.kind must be user or ai', 'invalid-author');
+    // Whoever does not say who they are is an agent: the editor always says (it knows the person)
+    return { name: name ?? (kind === 'user' ? 'User' : 'AI'), kind: kind ?? 'ai' };
+}
+export const commentAdd = defineOperation({
+    name: 'comment-add',
+    summary: 'Leaves a comment on an element of a page (or on the page, or on a shared component, when no element is given): a note for the people who work on the site, or for the agent that works on it. It is plain text, kept apart from the site (it is never published).',
+    params: [
+        ...SCOPE_PARAMS,
+        { name: 'id', type: 'string', help: 'the element the comment is about; without it, about the page (or shared component) itself' },
+        { name: 'text', type: 'string', required: true, help: `what to say (plain text, up to ${COMMENT_TEXT_MAX} characters)` },
+        { name: 'author', type: 'object', help: '{ name, kind }: kind is user (a person) or ai; an agent that does not say who it is, is ai' },
+    ],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const body = requiredText(input, 'text').trim();
+        if (!body)
+            throw invalid('the comment is empty', 'empty-comment');
+        if (body.length > COMMENT_TEXT_MAX)
+            throw invalid(`a comment has up to ${COMMENT_TEXT_MAX} characters`, 'comment-too-long');
+        const elementId = text(input, 'id');
+        const all = readComments(ctx);
+        if (all.length >= COMMENTS_MAX)
+            throw new OperationError(409, 'too-many-comments', `the project has ${COMMENTS_MAX} comments: resolve or delete some first`);
+        const comment = {
+            id: `c-${crypto.randomBytes(5).toString('hex')}`,
+            scope: scope.name,
+            ...(elementId ? { elementId } : {}),
+            text: body,
+            author: authorOf(input),
+            createdAt: new Date().toISOString(),
+            status: 'open',
+            ...(elementId ? { context: contextOf(ctx, scope, elementId) } : {}),
+        };
+        writeComments(ctx, [...all, comment]);
+        return { comment };
+    },
+});
+export const commentList = defineOperation({
+    name: 'comment-list',
+    readOnly: true,
+    summary: 'The comments left on the site: the open ones by default (what people asked for). Each has where it is (page and element), who wrote it, what the element was, and `orphan` when the element is no longer in the code. Start here when you are asked to work on the site.',
+    params: [
+        { name: 'page', type: 'string', help: 'only this page (or a shared component: _shared/header, _shared/<name>…)' },
+        { name: 'id', type: 'string', help: 'only this element (with page)' },
+        { name: 'status', type: 'string', choices: ['open', 'resolved', 'all'], default: 'open', help: 'open (default), resolved or all' },
+    ],
+    run: (input, ctx) => {
+        const page = text(input, 'page');
+        const id = text(input, 'id');
+        const status = text(input, 'status') ?? 'open';
+        if (!['open', 'resolved', 'all'].includes(status))
+            throw invalid('status must be open, resolved or all', 'invalid-status');
+        const all = readComments(ctx);
+        const wanted = all.filter(c => (page === undefined || c.scope === page) && (id === undefined || c.elementId === id) && (status === 'all' || c.status === status));
+        // An element that is not in the code any more: said, not guessed when some id is computed (any of them could be it)
+        const known = wanted.some(c => c.elementId) ? idsInCode(ctx) : null;
+        const comments = wanted.map(c => ({ ...c, orphan: known !== null && c.elementId !== undefined && !known.dynamicIds && !known.ids.has(c.elementId) }));
+        return { comments, open: all.filter(c => c.status === 'open').length };
+    },
+});
+export const commentResolve = defineOperation({
+    name: 'comment-resolve',
+    summary: 'Marks a comment as dealt with (or open again): it stays in the list of resolved ones. Do it after acting on what it asked, so the next run does not do it twice.',
+    params: [
+        { name: 'comment', type: 'string', positional: true, required: true, help: 'the comment\'s id (from comment-list)' },
+        { name: 'resolved', type: 'boolean', default: true, help: 'false opens it again' },
+    ],
+    run: (input, ctx) => {
+        const id = requiredText(input, 'comment');
+        const resolved = input.resolved !== false && input.resolved !== 'false';
+        const all = readComments(ctx);
+        const found = all.find(c => c.id === id);
+        if (!found)
+            throw new OperationError(404, 'comment-not-found', `no comment "${id}"`);
+        const { resolvedAt: _drop, ...rest } = found;
+        const next = resolved ? { ...rest, status: 'resolved', resolvedAt: new Date().toISOString() } : { ...rest, status: 'open' };
+        writeComments(ctx, all.map(c => (c.id === id ? next : c)));
+        return { comment: next };
+    },
+});
+export const commentDelete = defineOperation({
+    name: 'comment-delete',
+    destructive: true,
+    summary: 'Deletes a comment for good (resolve it to keep it as done).',
+    params: [{ name: 'comment', type: 'string', positional: true, required: true, help: 'the comment\'s id (from comment-list)' }],
+    run: (input, ctx) => {
+        const id = requiredText(input, 'comment');
+        const all = readComments(ctx);
+        if (!all.some(c => c.id === id))
+            throw new OperationError(404, 'comment-not-found', `no comment "${id}"`);
+        writeComments(ctx, all.filter(c => c.id !== id));
+        return { deleted: id };
+    },
+});
+export const COMMENT_OPERATIONS = [commentAdd, commentList, commentResolve, commentDelete];
+//# sourceMappingURL=comments.js.map

package/dist/operations/ops/content.d.ts

@@ -0,0 +1,16 @@
+export declare const pageOutline: import("../define.js").Operation;
+export interface ContentItem {
+    scope: string;
+    id: string;
+    kind: string;
+    /** The field: content, alt, ariaLabel. */
+    field: string;
+    /** What it says in each language (the default language is `default`). */
+    values: Record<string, string>;
+    /** The languages it has nothing in. */
+    missing: string[];
+}
+export declare const pageContent: import("../define.js").Operation;
+export declare const blocksList: import("../define.js").Operation;
+export declare const CONTENT_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=content.d.ts.map

package/dist/operations/ops/content.js

@@ -0,0 +1,73 @@
+import { wrLangKey } from '@webround/core/routing';
+import { WR_BLOCKS } from '../../blocks.js';
+import { checkScopeFromCode, sharedFollower } from '../../check/producer-code.js';
+import { walk } from '../../check/types.js';
+import { defineOperation, requiredText, text } from '../define.js';
+import { readLangs, scopesOfPage } from './project.js';
+// Reading a site: what is on a page, and what it says in each language. The same tree the checks judge (check/producer-code.ts): the
+// code, with the JSON of its values over it. Nothing here is a second reading of the project.
+const PAGE_PARAM = { name: 'page', type: 'string', positional: true, required: true, help: 'the page name (page-list shows them)' };
+export const pageOutline = defineOperation({
+    name: 'page-outline',
+    readOnly: true,
+    summary: 'What is on a page, as a tree: for each element its id, kind, tag, text, the attributes that matter, what it says in each language (values), whether it is hidden, and where in the code it is. Header and footer are listed on their own (_shared/header, _shared/footer), and the shared components the page uses (a card…) are inside it, each element with its `scope` (_shared/product-card): that name is the `page` to use to change them.',
+    params: [PAGE_PARAM],
+    run: (input, ctx) => {
+        const page = requiredText(input, 'page');
+        const follow = sharedFollower(ctx);
+        const scopes = scopesOfPage(ctx, page).map(scope => checkScopeFromCode(ctx, scope, { includeHidden: true, follow }));
+        return {
+            page,
+            scopes: scopes.map(({ name, file, nodes, syntax }) => ({ name, file, nodes, ...(syntax.length ? { syntax } : {}) })),
+            // What is wrong in the file of a shared component the page uses (the scopes above hold only header, page and footer)
+            ...(follow.syntax.length ? { sharedSyntax: follow.syntax } : {}),
+        };
+    },
+});
+export const pageContent = defineOperation({
+    name: 'page-content',
+    readOnly: true,
+    summary: 'Everything on a page that is translated (texts, alt texts, labels), in every language of the site, and which languages are missing for each. The default language is called "default" in the values.',
+    params: [
+        PAGE_PARAM,
+        { name: 'lang', type: 'string', help: 'only this language (a code of langs-get)' },
+    ],
+    run: (input, ctx) => {
+        const page = requiredText(input, 'page');
+        const langs = readLangs(ctx) ?? undefined;
+        // The languages of the site, each under the key it has in the JSON; a site that is not multilingual has just the default
+        const keys = langs ? [...new Set(langs.available.map(code => wrLangKey(code, langs)))] : ['default'];
+        const only = text(input, 'lang');
+        const wanted = only === undefined ? keys : [wrLangKey(only, langs)];
+        const items = [];
+        const follow = sharedFollower(ctx);
+        for (const scope of scopesOfPage(ctx, page)) {
+            const tree = checkScopeFromCode(ctx, scope, { includeHidden: true, follow });
+            walk(tree.nodes, (node) => {
+                if (!node.id || !node.values)
+                    return;
+                for (const [field, values] of Object.entries(node.values)) {
+                    items.push({
+                        scope: node.scope ?? scope.name, id: node.id, kind: node.kind, field,
+                        values: Object.fromEntries(Object.entries(values).filter(([key]) => only === undefined || wanted.includes(key))),
+                        missing: wanted.filter(key => values[key] === undefined),
+                    });
+                }
+            });
+        }
+        return {
+            page,
+            languages: langs ? langs.available.map(code => ({ code, key: wrLangKey(code, langs), ...(code === langs.default ? { default: true } : {}) })) : [{ code: 'default', key: 'default', default: true }],
+            items,
+            missingCount: items.reduce((sum, item) => sum + item.missing.length, 0),
+        };
+    },
+});
+export const blocksList = defineOperation({
+    name: 'blocks-list',
+    readOnly: true,
+    summary: 'The catalog of ready-made blocks the editor offers (sections, layouts, elements): each is JSX that node-insert takes by its id.',
+    run: () => ({ blocks: WR_BLOCKS.map(({ id, category, jsx }) => ({ id, category, jsx })) }),
+});
+export const CONTENT_OPERATIONS = [pageOutline, pageContent, blocksList];
+//# sourceMappingURL=content.js.map

package/dist/operations/ops/json.d.ts

@@ -0,0 +1,4 @@
+export declare const jsonRead: import("../define.js").Operation;
+export declare const jsonPatch: import("../define.js").Operation;
+export declare const JSON_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=json.d.ts.map

package/dist/operations/ops/json.js

@@ -0,0 +1,27 @@
+import { defineOperation, object, requiredText } from '../define.js';
+import { patchJsonFile, readJsonFile } from './project.js';
+// The raw access the editor's page needs to keep the values of its elements and its own history (an undo writes back exactly what was
+// there). An agent has meaningful operations for this (node-set, page-content…): these are not offered to it.
+export const jsonRead = defineOperation({
+    name: 'json-read',
+    readOnly: true,
+    summary: 'A JSON file of the project (relative to src/), or null if there is none.',
+    expose: 'editor',
+    params: [{ name: 'file', type: 'string', required: true, help: 'the file, relative to src/' }],
+    run: (input, ctx) => ({ value: readJsonFile(ctx, requiredText(input, 'file')) }),
+});
+export const jsonPatch = defineOperation({
+    name: 'json-patch',
+    summary: 'Merges values into a JSON file of the project (a null value removes the key).',
+    expose: 'editor',
+    params: [
+        { name: 'file', type: 'string', required: true, help: 'the file, relative to src/' },
+        { name: 'patch', type: 'object', required: true, help: 'the keys to write; null removes one' },
+    ],
+    run: (input, ctx) => {
+        patchJsonFile(ctx, requiredText(input, 'file'), object(input, 'patch', { required: true }));
+        return {};
+    },
+});
+export const JSON_OPERATIONS = [jsonRead, jsonPatch];
+//# sourceMappingURL=json.js.map

package/dist/operations/ops/langs.d.ts

@@ -0,0 +1,4 @@
+export declare const langsGet: import("../define.js").Operation;
+export declare const langsSet: import("../define.js").Operation;
+export declare const LANG_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=langs.d.ts.map

package/dist/operations/ops/langs.js

@@ -0,0 +1,32 @@
+import { langCodeValues } from '@webround/core/lang-codes';
+import { defineOperation, invalid, list, requiredText } from '../define.js';
+import { LANGS_FILE, patchJsonFile, readLangs } from './project.js';
+export const langsGet = defineOperation({
+    name: 'langs-get',
+    readOnly: true,
+    summary: 'The languages of the site: the default one and all the available ones. null while the site is not multilingual.',
+    run: (_input, ctx) => ({ langs: readLangs(ctx) }),
+});
+export const langsSet = defineOperation({
+    name: 'langs-set',
+    summary: 'Sets the languages of the site. Texts already written in a language that is taken away stay in the JSON (and come back if it is added again).',
+    params: [
+        { name: 'default', type: 'string', required: true, help: 'the default language code (it is not in the URL), e.g. it' },
+        { name: 'available', type: 'array', required: true, help: 'every language code of the site, the default included' },
+    ],
+    run: (input, ctx) => {
+        const defaultCode = requiredText(input, 'default');
+        const available = list(input, 'available', { required: true });
+        const known = new Set(langCodeValues);
+        const unknown = [...available, defaultCode].filter(code => !known.has(code));
+        if (unknown.length > 0)
+            throw invalid(`unknown language code: ${[...new Set(unknown)].join(', ')}`, 'invalid-language');
+        if (!available.includes(defaultCode))
+            throw invalid('the default language must be one of the available ones', 'invalid-language');
+        const langs = { default: defaultCode, available: [...new Set(available)] };
+        patchJsonFile(ctx, LANGS_FILE, { default: langs.default, available: langs.available });
+        return { langs };
+    },
+});
+export const LANG_OPERATIONS = [langsGet, langsSet];
+//# sourceMappingURL=langs.js.map

package/dist/operations/ops/nodes.d.ts

@@ -0,0 +1,8 @@
+export declare const nodeGet: import("../define.js").Operation;
+export declare const nodeSet: import("../define.js").Operation;
+export declare const nodeInsert: import("../define.js").Operation;
+export declare const nodeDelete: import("../define.js").Operation;
+export declare const nodeMove: import("../define.js").Operation;
+export declare const nodeSource: import("../define.js").Operation;
+export declare const NODE_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=nodes.d.ts.map

package/dist/operations/ops/nodes.js

@@ -0,0 +1,270 @@
+import fs from 'fs';
+import { wrLocalizeItems, wrSetLocalized } from '@webround/core/localized';
+import { getAllFields } from '../../schema.js';
+import { WR_BLOCKS } from '../../blocks.js';
+import { deleteJsx, findNode, insertJsx, moveJsx, readJsxLiteral, writeJsxLiteral } from '../../vite-plugins/jsx-tree.js';
+import { defineOperation, flag, invalid, object, OperationError, requiredText, text } from '../define.js';
+import { dropElementComments } from '../comments-store.js';
+import { langKeyOf, patchJsonFile, readJsonFile, scopeOfInput } from './project.js';
+// The elements of a page: read one, change one of its values, add markup, delete, move. The markup is code (the same JSX a developer writes
+// by hand), so every caller says the same thing; the values that are JSON (translated texts, hidden…) go where the schema says they live.
+const MODES = ['before', 'after', 'first-child', 'last-child'];
+const SCOPE_PARAMS = [
+    { name: 'page', type: 'string', help: 'the page (its name, e.g. home) or a shared component (_shared/header, _shared/footer, _shared/<name> as declared in config/shared.json)' },
+    { name: 'file', type: 'string', help: 'instead of page: the code file, relative to src/ (what the editor\'s own page sends)' },
+];
+const absolute = (ctx, scope) => ctx.resolveInSrc(scope.file);
+function findElement(ctx, scope, id) {
+    const file = absolute(ctx, scope);
+    if (!fs.existsSync(file))
+        throw new OperationError(404, 'file-not-found', `${scope.file} does not exist`);
+    const found = findNode(ctx.project(), file, id);
+    if (!found)
+        throw new OperationError(404, 'node-not-found', `no element with id "${id}" in ${scope.file}`);
+    return found;
+}
+/** A value for a field, in the type the field has (a toggle is true or false, whatever way it was said). */
+/** The entries of a list field as the caller gave them (a list, or a JSON string of one) written into the JSON, in a language. */
+function localizedEntries(field, current, value, lang) {
+    let entries = value;
+    if (typeof entries === 'string') {
+        try {
+            entries = JSON.parse(entries);
+        }
+        catch {
+            throw invalid(`${field.key} must be a list`, 'invalid-value');
+        }
+    }
+    if (!Array.isArray(entries) || entries.some(entry => typeof entry !== 'object' || entry === null || Array.isArray(entry)))
+        throw invalid(`${field.key} must be a list of entries: ${field.itemFields.map(f => f.key).join(', ')}`, 'invalid-value');
+    for (const entry of entries) {
+        for (const item of field.itemFields) {
+            const given = entry[item.key];
+            const ok = typeof given === 'string' || (item.multilang === true && typeof given === 'object' && given !== null);
+            if (!ok)
+                throw invalid(`every entry of ${field.key} needs a ${item.key} (text)`, 'invalid-value');
+        }
+    }
+    return wrLocalizeItems(current, entries, field.itemFields.filter(f => f.multilang).map(f => f.key), lang);
+}
+function coerce(field, value) {
+    const bad = (why) => invalid(`${field.key} ${why}`, 'invalid-value');
+    switch (field.type) {
+        case 'toggle':
+            if (typeof value === 'boolean')
+                return value;
+            if (value === 'true' || value === 'false')
+                return value === 'true';
+            throw bad('must be true or false');
+        case 'number': {
+            const n = typeof value === 'number' ? value : typeof value === 'string' && value.trim() !== '' ? Number(value) : NaN;
+            if (!Number.isFinite(n))
+                throw bad('must be a number');
+            return n;
+        }
+        case 'select':
+            if (typeof value !== 'string' || !field.options.includes(value))
+                throw bad(`must be one of: ${field.options.join(', ')}`);
+            return value;
+        default:
+            if (typeof value !== 'string')
+                throw bad('must be text');
+            return value;
+    }
+}
+export const nodeGet = defineOperation({
+    name: 'node-get',
+    readOnly: true,
+    summary: 'One element of a page: what kind it is, the values written in the code (src, href…) and the ones in the JSON (texts per language, hidden…).',
+    params: [...SCOPE_PARAMS, { name: 'id', type: 'string', positional: true, required: true, help: 'the element id (its data-wr-id)' }],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const id = requiredText(input, 'id');
+        const found = findElement(ctx, scope, id);
+        const fields = getAllFields(found.kind).filter(f => f.backend === 'ast');
+        const values = {};
+        for (const f of fields) {
+            const { present, value } = readJsxLiteral(found.node, f.key);
+            if (present && value !== undefined)
+                values[f.key] = value;
+        }
+        const json = (readJsonFile(ctx, scope.json) ?? {})[id] ?? null;
+        return { kind: found.kind, fields: fields.map(f => f.key), values, json };
+    },
+});
+export const nodeSet = defineOperation({
+    name: 'node-set',
+    summary: 'Sets one value of an element: where it is stored (the code, or the JSON) is decided by its kind\'s schema. A translated value (a text, an alt, the labels of a menu\'s entries) is written in the language asked for, and the other languages are kept; a list (`items` of a nav) is given whole, as a list of { label, href }. A text\'s content is HTML; plain text is fine.',
+    params: [
+        ...SCOPE_PARAMS,
+        { name: 'id', type: 'string', positional: true, required: true, help: 'the element id' },
+        { name: 'key', type: 'string', required: true, help: 'the value: content, alt, src, href, hidden, ariaLabel… (what the element\'s kind has)' },
+        { name: 'value', type: 'any', required: true, help: 'the new value; null takes a code value (src, href…) away' },
+        { name: 'lang', type: 'string', help: 'the language of a translated value, or of the translated fields of the entries of a list (a menu\'s labels): a code of langs-get; the default language if not said' },
+    ],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const id = requiredText(input, 'id');
+        const key = requiredText(input, 'key');
+        const found = findElement(ctx, scope, id);
+        const field = getAllFields(found.kind).find(f => f.key === key);
+        if (!field) {
+            const known = getAllFields(found.kind).map(f => f.key);
+            throw invalid(`a ${found.kind} has no "${key}" (it has: ${known.join(', ') || 'nothing to set'})`, 'unknown-field');
+        }
+        const value = input.value;
+        if (field.backend === 'ast') {
+            const previous = readJsxLiteral(found.node, key);
+            writeJsxLiteral(found.node, key, value === null ? null : coerce(field, value));
+            found.node.getSourceFile().saveSync();
+            return { backend: 'ast', previous: previous.present ? previous.value : null };
+        }
+        // The JSON: the element's own object, one key of it
+        const all = readJsonFile(ctx, scope.json) ?? {};
+        const current = all[id] ?? {};
+        let next;
+        let lang;
+        if (field.multilang) {
+            if (typeof value !== 'string')
+                throw invalid(`${key} must be text`, 'invalid-value');
+            lang = langKeyOf(ctx, text(input, 'lang'));
+            next = wrSetLocalized(current[key], lang, value);
+        }
+        else if (field.type === 'list') {
+            // The entries of a list (a menu): what is translated in them is written in the language asked for, the others are kept
+            lang = langKeyOf(ctx, text(input, 'lang'));
+            next = localizedEntries(field, current[key], value, lang);
+        }
+        else {
+            next = value === null ? null : coerce(field, value);
+        }
+        const updated = { ...current };
+        if (next === null)
+            delete updated[key];
+        else
+            updated[key] = next;
+        patchJsonFile(ctx, scope.json, { [id]: updated });
+        return { backend: 'json', ...(lang ? { lang } : {}), previous: current[key] ?? null };
+    },
+});
+function anchorOf(input) {
+    const given = object(input, 'anchor');
+    if (given) {
+        if ('root' in given ? given.root === true : typeof given.id === 'string')
+            return given;
+        throw invalid('anchor must be { id } or { root: true }', 'anchor-not-found');
+    }
+    const id = text(input, 'anchorId');
+    return id ? { id } : null;
+}
+const ANCHOR_PARAMS = [
+    { name: 'anchor', type: 'object', help: 'where: { id: "<element id>" } or { root: true } (the page itself); what the editor sends' },
+    { name: 'anchorId', type: 'string', help: 'where, as just the element id; without it (and without anchor) the page itself' },
+];
+export const nodeInsert = defineOperation({
+    name: 'node-insert',
+    summary: 'Adds markup to a page, next to an element or inside one (a section). Give the JSX itself, or the id of a block of the catalog (blocks-list). Ids that are taken are renumbered; the imports and the indentation are taken care of. The result has the final ids.',
+    params: [
+        ...SCOPE_PARAMS,
+        ...ANCHOR_PARAMS,
+        { name: 'mode', type: 'string', choices: [...MODES], help: 'before, after, first-child or last-child of the anchor (default: after an element, last-child of the page)' },
+        { name: 'block', type: 'string', help: 'the id of a block of the catalog (blocks-list)' },
+        { name: 'jsx', type: 'string', help: 'markup to insert: one or more elements, written the way you would write them by hand' },
+        { name: 'uniqueIds', type: 'boolean', default: true, help: 'renumber ids that are already taken (false refuses instead)' },
+        { name: 'jsonSeed', type: 'object', help: 'initial JSON values for the new elements: { "<id>": { … } }' },
+    ],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const blockId = text(input, 'block');
+        let jsx = text(input, 'jsx');
+        if (blockId !== undefined) {
+            const block = WR_BLOCKS.find(b => b.id === blockId);
+            if (!block)
+                throw invalid(`no block "${blockId}" (blocks-list shows them)`, 'unknown-block');
+            jsx = block.jsx;
+        }
+        if (typeof jsx !== 'string' || !jsx.trim())
+            throw invalid('jsx (or block) required', 'invalid-jsx');
+        const anchor = anchorOf(input) ?? { root: true };
+        const requested = text(input, 'mode');
+        if (requested !== undefined && !MODES.includes(requested))
+            throw invalid(`mode must be one of: ${MODES.join(', ')}`, 'invalid-mode');
+        const mode = requested ?? ('root' in anchor ? 'last-child' : 'after');
+        const result = insertJsx(ctx.project(), absolute(ctx, scope), { jsx, anchor, mode, uniqueIds: flag(input, 'uniqueIds') });
+        if (!result.ok)
+            throw new OperationError(result.status, result.code, result.error);
+        // The initial values were for the ids asked for: they follow the ones that were changed
+        const seed = object(input, 'jsonSeed');
+        if (seed)
+            patchJsonFile(ctx, scope.json, Object.fromEntries(Object.entries(seed).map(([id, value]) => [result.idMap[id] ?? id, value])));
+        return { ids: result.ids, rootIds: result.rootIds, undoable: result.undoable, idMap: result.idMap, jsx: result.jsx, scope: scope.name };
+    },
+});
+export const nodeDelete = defineOperation({
+    name: 'node-delete',
+    destructive: true,
+    summary: 'Deletes an element with everything it contains, and the JSON values (texts, translations…) and the comments of all of them. The root of the header or footer cannot be deleted.',
+    params: [
+        ...SCOPE_PARAMS,
+        { name: 'id', type: 'string', positional: true, required: true, help: 'the element id' },
+        { name: 'pruneImports', type: 'boolean', default: false, help: 'also remove the imports nothing uses any more' },
+    ],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const id = requiredText(input, 'id');
+        const removed = deleteJsx(ctx.project(), absolute(ctx, scope), id, { pruneImports: flag(input, 'pruneImports') === true });
+        if (!removed)
+            throw new OperationError(404, 'node-not-found', `no element with id "${id}" in ${scope.file}`);
+        if ('refused' in removed)
+            throw new OperationError(422, removed.code, removed.error);
+        // What was written for them goes too: a key left behind would bring the old text back the day an element takes the id again.
+        // What it held comes back, so a caller that can undo can put it back.
+        const all = readJsonFile(ctx, scope.json) ?? {};
+        const removedJson = Object.fromEntries(removed.removedIds.filter(removedId => removedId in all).map(removedId => [removedId, all[removedId]]));
+        if (Object.keys(removedJson).length > 0)
+            patchJsonFile(ctx, scope.json, Object.fromEntries(Object.keys(removedJson).map(removedId => [removedId, null])));
+        // And what was said about them: not restored by an undo (comments are not in the history)
+        const removedComments = dropElementComments(ctx, scope.name, removed.removedIds);
+        return { ...removed, removedJson, removedComments, scope: scope.name };
+    },
+});
+export const nodeMove = defineOperation({
+    name: 'node-move',
+    summary: 'Moves an element, with everything it contains, to another place in the same page (or header, or footer). It answers where it was.',
+    params: [
+        ...SCOPE_PARAMS,
+        { name: 'id', type: 'string', positional: true, required: true, help: 'the element to move' },
+        ...ANCHOR_PARAMS,
+        { name: 'mode', type: 'string', required: true, choices: [...MODES], help: 'before, after, first-child or last-child of the anchor' },
+    ],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const id = requiredText(input, 'id');
+        const anchor = anchorOf(input) ?? { root: true };
+        const mode = requiredText(input, 'mode');
+        if (!MODES.includes(mode))
+            throw invalid(`mode must be one of: ${MODES.join(', ')}`, 'invalid-mode');
+        const result = moveJsx(ctx.project(), absolute(ctx, scope), { id, anchor, mode: mode });
+        if (!result.ok)
+            throw new OperationError(result.status, result.code, result.error);
+        return { id: result.id, from: result.from, scope: scope.name };
+    },
+});
+export const nodeSource = defineOperation({
+    name: 'node-source',
+    readOnly: true,
+    summary: 'The markup of an element with everything it contains, as written in the code, and the JSON values (texts, translations…) of all of them: what node-insert takes, so a copy is one insert away (this is how an element is duplicated).',
+    params: [...SCOPE_PARAMS, { name: 'id', type: 'string', positional: true, required: true, help: 'the element id' }],
+    run: (input, ctx) => {
+        const scope = scopeOfInput(ctx, input);
+        const id = requiredText(input, 'id');
+        const found = findElement(ctx, scope, id);
+        const jsx = found.full.getText();
+        // The ids written in it (the element's own and its children's): their values in the JSON go with it
+        const ids = [...jsx.matchAll(/\bid=(?:"([^"]+)"|'([^']+)'|\{["']([^"']+)["']\})/g)].map(m => m[1] ?? m[2] ?? m[3]);
+        const all = readJsonFile(ctx, scope.json) ?? {};
+        return { jsx, ids, json: Object.fromEntries(ids.filter(i => i in all).map(i => [i, all[i]])), scope: scope.name };
+    },
+});
+export const NODE_OPERATIONS = [nodeGet, nodeSet, nodeInsert, nodeDelete, nodeMove, nodeSource];
+//# sourceMappingURL=nodes.js.map

package/dist/operations/ops/pages.d.ts

@@ -0,0 +1,8 @@
+/** The file a new page starts as. */
+export declare function wrPageScaffold(component: string): string;
+export declare const pageList: import("../define.js").Operation;
+export declare const pageCreate: import("../define.js").Operation;
+export declare const pageDelete: import("../define.js").Operation;
+export declare const pageUpdate: import("../define.js").Operation;
+export declare const PAGE_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=pages.d.ts.map