@webround/editor 0.0.0-stage → 0.3.0

package/dist/messages.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messages.js.map

package/dist/nav.d.ts

@@ -0,0 +1,5 @@
+/** What the page's path is, as the editor knows it: the preview's own prefix is not part of it. */
+export declare const pathOf: (pathname: string) => string;
+/** The path to tell the editor, or null when it is the one it was last told (a change of the query or of the hash only). `last` is null before anything was told. */
+export declare function navigationTo(last: string | null, pathname: string): string | null;
+//# sourceMappingURL=nav.d.ts.map

package/dist/nav.js

@@ -0,0 +1,10 @@
+// When the page the preview shows changed: the path is what says which page it is. A change of the query or of the hash only (a shop's filters, a search, the page of a listing) is the same page
+// in another state: it is not told to the editor and what is selected stays selected.
+/** What the page's path is, as the editor knows it: the preview's own prefix is not part of it. */
+export const pathOf = (pathname) => pathname.replace(/^\/preview(?=\/|$)/, '') || '/';
+/** The path to tell the editor, or null when it is the one it was last told (a change of the query or of the hash only). `last` is null before anything was told. */
+export function navigationTo(last, pathname) {
+    const path = pathOf(pathname);
+    return path === last ? null : path;
+}
+//# sourceMappingURL=nav.js.map

package/dist/operations/animations-store.d.ts

@@ -0,0 +1,6 @@
+import { type OperationContext } from './define.js';
+/** The entry animations a className uses (`motion-safe:animate-fade-in`, at any screen). */
+export declare const entryAnimationsIn: (className: string) => string[];
+/** Makes sure the theme has what the entry animations in this className need; nothing is written when it has it already. A site without `theme.css` cannot run them, and is told before anything is written. */
+export declare function ensureEntryAnimations(ctx: OperationContext, className: string): void;
+//# sourceMappingURL=animations-store.d.ts.map

package/dist/operations/animations-store.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import postcss from 'postcss';
+import { WR_ENTRY_ANIMATIONS, WR_ENTRY_ANIMATIONS_CSS, wrParseClassName } from '@webround/core/style';
+import { OperationError } from './define.js';
+// The entry animations (fade in, slide up, zoom in) are the project's, not Tailwind's: the class `animate-fade-in` exists because the theme has `--animate-fade-in` and its keyframes in an
+// `@theme`. This is the ONE place that writes them into `src/theme.css`, the first time a class uses one. The text of them is `WR_ENTRY_ANIMATIONS_CSS` (core): the tests compile the same.
+const INTRO = 'Entry animations (fade in, slide up, zoom in), used as animate-fade-in… from the editor\'s Motion. They run with `motion-safe:`, so not for who asked their system for less motion.';
+/** How the file indents (the first thing nested in a rule), so what is written looks like what is there. */
+function indentOf(root) {
+    let found = '';
+    root.walkDecls((decl) => {
+        if (!found && decl.parent?.type === 'rule' && /^\n[ \t]+$/.test(decl.raws.before ?? ''))
+            found = decl.raws.before.slice(1);
+    });
+    return found || '  ';
+}
+const isPlainTheme = (n) => n.type === 'atrule' && n.name === 'theme' && n.params.trim() === '';
+/** The entry animations a className uses (`motion-safe:animate-fade-in`, at any screen). */
+export const entryAnimationsIn = (className) => WR_ENTRY_ANIMATIONS.filter(id => wrParseClassName(className).some(t => t.utility === `animate-${id}`));
+/** Makes sure the theme has what the entry animations in this className need; nothing is written when it has it already. A site without `theme.css` cannot run them, and is told before anything is written. */
+export function ensureEntryAnimations(ctx, className) {
+    const used = entryAnimationsIn(className);
+    if (used.length === 0)
+        return;
+    const file = path.join(ctx.srcRoot, 'theme.css');
+    if (!fs.existsSync(file))
+        throw new OperationError(409, 'no-theme-file', `this site has no src/theme.css: the keyframes of ${used.map(id => `animate-${id}`).join(', ')} are kept there`);
+    const root = postcss.parse(fs.readFileSync(file, 'utf-8'));
+    let block = root.nodes.find(isPlainTheme);
+    const indent = indentOf(root);
+    let changed = false;
+    for (const id of used) {
+        if (block?.nodes?.some(n => n.type === 'decl' && n.prop === `--animate-${id}`))
+            continue;
+        if (!block) {
+            block = postcss.atRule({ name: 'theme', params: '', nodes: [] });
+            block.raws.before = '\n\n';
+            block.raws.afterName = '';
+            block.raws.between = ' ';
+            const intro = postcss.comment({ text: INTRO });
+            intro.raws.before = `\n${indent}`;
+            block.prepend(intro);
+            root.append(block);
+        }
+        const { value, keyframes } = WR_ENTRY_ANIMATIONS_CSS[id];
+        block.append(postcss.decl({ prop: `--animate-${id}`, value }));
+        const frames = postcss.atRule({ name: 'keyframes', params: value.split(' ')[0] });
+        frames.raws.before = `\n\n${indent}`;
+        frames.raws.between = ' ';
+        frames.raws.after = `\n${indent}`;
+        // (a copy: appending a frame takes it out of the list being walked)
+        for (const frame of [...postcss.parse(keyframes).nodes]) {
+            frame.raws.before = `\n${indent}${indent}`;
+            frames.append(frame);
+        }
+        block.append(frames);
+        changed = true;
+    }
+    if (changed)
+        fs.writeFileSync(file, root.toString());
+}
+//# sourceMappingURL=animations-store.js.map

package/dist/operations/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/operations/cli.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { createOperationContext } from './context.js';
+import { OperationError } from './define.js';
+import { createRegistry } from './registry.js';
+// wr-op: the operations on the project in the current folder, as a command.
+//
+//   wr-op list [--all]               the operations as JSON (--all: the editor's own too)
+//   wr-op run <name> [--input '{}']  run one; the input is JSON, from --input or from the standard input
+//
+// The answer is always one JSON document: { ok: true, data } or { ok: false, code, error, status }; the exit code is 1 when it is not ok.
+// It is what the container's tools run (see webround-dev-container/image/tools): the editor's page and an agent do the same things
+// through the same code.
+const [command, ...rest] = process.argv.slice(2);
+const registry = createRegistry();
+const print = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
+function readInput() {
+    const at = rest.indexOf('--input');
+    const raw = at !== -1 ? rest[at + 1] ?? '' : process.stdin.isTTY ? '' : fs.readFileSync(0, 'utf-8');
+    if (!raw.trim())
+        return {};
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new OperationError(400, 'invalid-input', 'the input must be a JSON object');
+    return parsed;
+}
+async function main() {
+    if (command === 'list') {
+        print({ operations: registry.list({ all: rest.includes('--all') }) });
+        return 0;
+    }
+    if (command === 'run' && rest[0]) {
+        try {
+            const data = await registry.run(rest[0], readInput(), createOperationContext(process.cwd()));
+            print({ ok: true, data });
+            return 0;
+        }
+        catch (err) {
+            if (err instanceof OperationError)
+                print({ ok: false, status: err.status, code: err.code, error: err.message });
+            else if (err instanceof SyntaxError)
+                print({ ok: false, status: 400, code: 'invalid-input', error: `the input is not JSON: ${err.message}` });
+            else
+                print({ ok: false, status: 500, code: 'internal', error: err instanceof Error ? err.message : String(err) });
+            return 1;
+        }
+    }
+    process.stderr.write('usage: wr-op list [--all] | wr-op run <name> [--input <json>]\n');
+    return 2;
+}
+process.exitCode = await main();
+//# sourceMappingURL=cli.js.map

package/dist/operations/comments-store.d.ts

@@ -0,0 +1,17 @@
+import type { WrComment } from '../messages';
+import { type OperationContext } from './define.js';
+export declare const COMMENTS_FILE: string;
+export declare const COMMENT_TEXT_MAX = 2000;
+export declare const COMMENTS_MAX = 1000;
+export type CommentStatus = WrComment['status'];
+export type { WrComment };
+/** Every comment of the project. A project with none (no file) has an empty list; a file that cannot be read is an error, never an empty list: it would be overwritten. */
+export declare function readComments(ctx: OperationContext): WrComment[];
+export declare function writeComments(ctx: OperationContext, comments: WrComment[]): void;
+/** The comments of elements that are gone (the element and everything it contained): they go with them. Answers how many. */
+export declare function dropElementComments(ctx: OperationContext, scope: string, elementIds: readonly string[]): number;
+/** Everything said about a page that is deleted (its elements and the page itself). */
+export declare const dropScopeComments: (ctx: OperationContext, scope: string) => number;
+/** A page that is renamed keeps its comments. */
+export declare function renameScopeComments(ctx: OperationContext, from: string, to: string): void;
+//# sourceMappingURL=comments-store.d.ts.map

package/dist/operations/comments-store.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import { OperationError } from './define.js';
+// The comments people (and an agent) leave on the elements of a site. They are NOT the site's: they live in `.wr/comments.json`, at the
+// root of the project, where nothing the site imports can reach them, so they are never in the published build. ONE file, ONE reader and
+// writer (this module): the operations, and what happens to a comment when its element or its page goes, all come through here.
+export const COMMENTS_FILE = path.join('.wr', 'comments.json');
+export const COMMENT_TEXT_MAX = 2000;
+export const COMMENTS_MAX = 1000;
+const fileOf = (ctx) => path.join(ctx.root, COMMENTS_FILE);
+/** Every comment of the project. A project with none (no file) has an empty list; a file that cannot be read is an error, never an empty list: it would be overwritten. */
+export function readComments(ctx) {
+    const file = fileOf(ctx);
+    if (!fs.existsSync(file))
+        return [];
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (!Array.isArray(parsed.comments))
+            throw new Error('no list of comments');
+        return parsed.comments;
+    }
+    catch (err) {
+        throw new OperationError(500, 'comments-unreadable', `${COMMENTS_FILE} cannot be read (${err instanceof Error ? err.message : 'invalid'}): fix or remove it`);
+    }
+}
+export function writeComments(ctx, comments) {
+    const file = fileOf(ctx);
+    if (comments.length === 0) {
+        // Nothing to keep: the file goes, and so does the folder when it was only for it
+        fs.rmSync(file, { force: true });
+        try {
+            fs.rmdirSync(path.dirname(file));
+        }
+        catch { /* it holds something else */ }
+        return;
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ comments }, null, 2));
+}
+function rewrite(ctx, change) {
+    const all = readComments(ctx);
+    const next = change(all);
+    if (next.length !== all.length || next.some((c, i) => c !== all[i]))
+        writeComments(ctx, next);
+    return all.length - next.length;
+}
+/** The comments of elements that are gone (the element and everything it contained): they go with them. Answers how many. */
+export function dropElementComments(ctx, scope, elementIds) {
+    if (elementIds.length === 0)
+        return 0;
+    const gone = new Set(elementIds);
+    return rewrite(ctx, all => all.filter(c => !(c.scope === scope && c.elementId !== undefined && gone.has(c.elementId))));
+}
+/** Everything said about a page that is deleted (its elements and the page itself). */
+export const dropScopeComments = (ctx, scope) => rewrite(ctx, all => all.filter(c => c.scope !== scope));
+/** A page that is renamed keeps its comments. */
+export function renameScopeComments(ctx, from, to) {
+    if (from === to)
+        return;
+    rewrite(ctx, all => all.map(c => (c.scope === from ? { ...c, scope: to } : c)));
+}
+//# sourceMappingURL=comments-store.js.map

package/dist/operations/context.d.ts

@@ -0,0 +1,12 @@
+import { Project } from 'ts-morph';
+import type { OperationContext } from './define.js';
+/** A path relative to `src/` made absolute, or null when it leaves `src/` (traversal, an absolute path, a null byte). */
+export declare function resolveInside(srcRoot: string, file: unknown): string | null;
+export declare const isSafePageName: (v: unknown) => v is string;
+export declare const isSafeComponentName: (v: unknown) => v is string;
+export interface ContextOptions {
+    /** Another project to work on (tests use one in memory); by default the one of the project's tsconfig. */
+    project?: () => Project;
+}
+export declare function createOperationContext(root?: string, options?: ContextOptions): OperationContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/operations/context.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import path from 'path';
+import { Project } from 'ts-morph';
+/** A path relative to `src/` made absolute, or null when it leaves `src/` (traversal, an absolute path, a null byte). */
+export function resolveInside(srcRoot, file) {
+    if (typeof file !== 'string' || file.includes('\0'))
+        return null;
+    const resolved = path.resolve(srcRoot, file);
+    return resolved.startsWith(srcRoot + path.sep) ? resolved : null;
+}
+// Names that end up in paths and in generated code: never trust arbitrary strings.
+// A page name is a route path (`about`, `blog/post`, `shop/[slug]`), and it ends up in file paths (`config/pages/<name>.json`): every segment
+// is a plain word or a `[parameter]`, so nothing can climb out of the folder (no `..`, no empty segment, no leading slash or underscore).
+const PAGE_SEGMENT = /^(?:[A-Za-z0-9][A-Za-z0-9_-]*|\[[A-Za-z][A-Za-z0-9_]*\])$/;
+export const isSafePageName = (v) => typeof v === 'string' && /^[A-Za-z0-9[]/.test(v) && v.split('/').every(segment => PAGE_SEGMENT.test(segment));
+export const isSafeComponentName = (v) => typeof v === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(v);
+/** The project's own tsconfig when it has one; a project without it (a bare folder) still reads and writes JSX. */
+function defaultProject(root) {
+    const tsConfigFilePath = path.resolve(root, 'tsconfig.json');
+    return fs.existsSync(tsConfigFilePath)
+        ? new Project({ tsConfigFilePath, skipAddingFilesFromTsConfig: true })
+        : new Project({ skipAddingFilesFromTsConfig: true, compilerOptions: { jsx: 4 } });
+}
+export function createOperationContext(root = process.cwd(), options = {}) {
+    const srcRoot = path.resolve(root, 'src');
+    let project;
+    return {
+        root,
+        srcRoot,
+        publicRoot: path.resolve(root, 'public'),
+        resolveInSrc: file => resolveInside(srcRoot, file),
+        project: () => (project ??= options.project?.() ?? defaultProject(root)),
+    };
+}
+//# sourceMappingURL=context.js.map

package/dist/operations/define.d.ts

@@ -0,0 +1,81 @@
+import type { Project } from 'ts-morph';
+/** How a parameter is described: plain data, the same shape the container's tools use (image/tools/registry.mjs), so one can feed the other. */
+export interface ParamSpec {
+    name: string;
+    /** `any`: whatever JSON value (the operation checks it against what it is for). */
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+    help: string;
+    required?: boolean;
+    default?: unknown;
+    choices?: string[];
+    /** The first bare word on a command line. */
+    positional?: boolean;
+}
+/** Why an operation did not do what was asked: a status like HTTP's, a code a caller can act on, and the words. */
+export declare class OperationError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export interface OperationContext {
+    /** The project's root (where package.json is). */
+    root: string;
+    /** `src/` of the project: the only place operations read and write. */
+    srcRoot: string;
+    /** `public/` of the project: what is served as it is (robots.txt, the sitemaps). Only the SEO files are written there. */
+    publicRoot: string;
+    /** A path relative to `src/`, made absolute; null when it would leave `src/` (a traversal, an absolute path, a null byte). */
+    resolveInSrc(file: unknown): string | null;
+    /** The ts-morph project the code operations work on (created the first time it is asked for). */
+    project(): Project;
+}
+export type OperationInput = Record<string, unknown>;
+export interface Operation {
+    name: string;
+    summary: string;
+    /** The draft permission it needs from outside: "write" is site:update (the default), "view" is site:read. */
+    access: 'view' | 'write';
+    /**
+     * Who may use it: "all" (the editor and an agent) or "editor" (only the page's own client: the raw access it needs for its history,
+     * which an agent has a better, meaningful operation for).
+     */
+    expose: 'all' | 'editor';
+    params: ParamSpec[];
+    /** It changes nothing in the project: a client may let it run without asking. */
+    readOnly: boolean;
+    /** It takes something away (an element, a page, a theme item): a client may ask first. */
+    destructive: boolean;
+    run(input: OperationInput, ctx: OperationContext): unknown | Promise<unknown>;
+}
+export declare function defineOperation(op: Pick<Operation, 'name' | 'summary' | 'run'> & Partial<Pick<Operation, 'access' | 'expose' | 'params' | 'readOnly' | 'destructive'>>): Operation;
+export declare const invalid: (message: string, code?: string) => OperationError;
+export declare function text(input: OperationInput, key: string, options?: {
+    required?: boolean;
+}): string | undefined;
+export declare const requiredText: (input: OperationInput, key: string) => string;
+export declare function flag(input: OperationInput, key: string): boolean | undefined;
+export declare function list(input: OperationInput, key: string, options?: {
+    required?: boolean;
+}): string[] | undefined;
+export declare function object(input: OperationInput, key: string, options?: {
+    required?: boolean;
+}): Record<string, unknown> | undefined;
+export interface OperationDescription {
+    name: string;
+    summary: string;
+    access: Operation['access'];
+    expose: Operation['expose'];
+    params: ParamSpec[];
+    readOnly: boolean;
+    destructive: boolean;
+}
+export interface OperationRegistry {
+    /** What there is, as plain data. `all` includes the editor-only ones. */
+    list(options?: {
+        all?: boolean;
+    }): OperationDescription[];
+    get(name: string): Operation | undefined;
+    run(name: string, input: OperationInput, ctx: OperationContext): Promise<unknown>;
+}
+export declare function createOperationRegistry(operations: readonly Operation[]): OperationRegistry;
+//# sourceMappingURL=define.d.ts.map

package/dist/operations/define.js

@@ -0,0 +1,86 @@
+/** Why an operation did not do what was asked: a status like HTTP's, a code a caller can act on, and the words. */
+export class OperationError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export function defineOperation(op) {
+    if (!/^[a-z][a-z0-9-]*$/.test(op.name))
+        throw new Error(`operation name must be lowercase words: ${op.name}`);
+    if (op.readOnly && op.destructive)
+        throw new Error(`operation ${op.name}: it cannot be both read-only and destructive`);
+    return { access: 'write', expose: 'all', params: [], readOnly: false, destructive: false, ...op };
+}
+// ── Reading what a caller gave, with the same words for every operation ──────
+export const invalid = (message, code = 'invalid-input') => new OperationError(400, code, message);
+export function text(input, key, options = {}) {
+    const value = input[key];
+    if (value === undefined || value === null) {
+        if (options.required)
+            throw invalid(`${key} required`);
+        return undefined;
+    }
+    if (typeof value !== 'string')
+        throw invalid(`${key} must be text`);
+    if (options.required && !value)
+        throw invalid(`${key} required`);
+    return value;
+}
+export const requiredText = (input, key) => text(input, key, { required: true });
+export function flag(input, key) {
+    const value = input[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'boolean')
+        throw invalid(`${key} must be true or false`);
+    return value;
+}
+export function list(input, key, options = {}) {
+    const value = input[key];
+    if (value === undefined || value === null) {
+        if (options.required)
+            throw invalid(`${key} required`);
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some(item => typeof item !== 'string'))
+        throw invalid(`${key} must be a list of text`);
+    return value;
+}
+export function object(input, key, options = {}) {
+    const value = input[key];
+    if (value === undefined || value === null) {
+        if (options.required)
+            throw invalid(`${key} required`);
+        return undefined;
+    }
+    if (typeof value !== 'object' || Array.isArray(value))
+        throw invalid(`${key} must be an object`);
+    return value;
+}
+export function createOperationRegistry(operations) {
+    const byName = new Map();
+    for (const op of operations) {
+        if (byName.has(op.name))
+            throw new Error(`two operations are called ${op.name}`);
+        byName.set(op.name, op);
+    }
+    return {
+        list: ({ all = false } = {}) => [...byName.values()]
+            .filter(op => all || op.expose === 'all')
+            .map(({ name, summary, access, expose, params, readOnly, destructive }) => ({ name, summary, access, expose, params, readOnly, destructive })),
+        get: name => byName.get(name),
+        async run(name, input, ctx) {
+            const op = byName.get(name);
+            if (!op)
+                throw new OperationError(404, 'unknown-operation', `no operation called "${name}"`);
+            if (typeof input !== 'object' || input === null || Array.isArray(input))
+                throw invalid('the input must be an object');
+            return op.run(input, ctx);
+        },
+    };
+}
+//# sourceMappingURL=define.js.map

package/dist/operations/index.d.ts

@@ -0,0 +1,6 @@
+export * from './define.js';
+export { createOperationContext, resolveInside, isSafePageName, isSafeComponentName } from './context.js';
+export { OPERATIONS, createRegistry } from './registry.js';
+export { wrPageScaffold } from './ops/pages.js';
+export { writeSeoFiles } from './ops/seo.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/operations/index.js

@@ -0,0 +1,6 @@
+export * from './define.js';
+export { createOperationContext, resolveInside, isSafePageName, isSafeComponentName } from './context.js';
+export { OPERATIONS, createRegistry } from './registry.js';
+export { wrPageScaffold } from './ops/pages.js';
+export { writeSeoFiles } from './ops/seo.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,5 @@
+export declare const projectCheck: import("../define.js").Operation;
+export declare const issueMute: import("../define.js").Operation;
+export declare const jsonPrune: import("../define.js").Operation;
+export declare const CHECK_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=check.d.ts.map

package/dist/operations/ops/check.js

@@ -0,0 +1,53 @@
+import { wrPageConfigPath } from '@webround/core/routing';
+import { CHECKS_FILE, checkProject, mutedKeys } from '../../check/project.js';
+import { findOrphanKeys } from '../../check/orphans.js';
+import { defineOperation, flag, invalid, OperationError, requiredText, text } from '../define.js';
+import { patchJsonFile } from './project.js';
+export const projectCheck = defineOperation({
+    name: 'project-check',
+    readOnly: true,
+    // An agent already has `check` (the same function, run as a command in the container): this is how the editor's page asks
+    expose: 'editor',
+    summary: 'Everything wr-check finds in the project, in every language of the site: problems of the pages (an image without alt text, a missing title, a broken link…) and of the site (no favicon…), each with where to fix it and the languages it happens in.',
+    run: (_input, ctx) => ({ issues: checkProject(ctx.root), muted: mutedKeys(ctx.root) }),
+});
+export const issueMute = defineOperation({
+    name: 'issue-mute',
+    expose: 'editor',
+    summary: 'Silences a problem the person chose not to deal with (or brings it back): it stays in the project, counted apart, and wr-check no longer fails because of it. The key is the one the problem has in project-check.',
+    params: [
+        { name: 'key', type: 'string', positional: true, required: true, help: 'the problem\'s key' },
+        { name: 'muted', type: 'boolean', default: true, help: 'false brings the problem back' },
+    ],
+    run: (input, ctx) => {
+        const key = requiredText(input, 'key');
+        if (key.length > 300 || !key.includes('|'))
+            throw invalid('that is not a problem key', 'invalid-key');
+        const muted = flag(input, 'muted') !== false;
+        const current = new Set(mutedKeys(ctx.root));
+        if (muted)
+            current.add(key);
+        else
+            current.delete(key);
+        patchJsonFile(ctx, CHECKS_FILE, { muted: current.size > 0 ? [...current].sort() : null });
+        return { muted: [...current].sort() };
+    },
+});
+export const jsonPrune = defineOperation({
+    name: 'json-prune',
+    destructive: true,
+    summary: 'Removes from the JSON the values of elements that are no longer in the code (their keys stay behind when an element is deleted or renamed in the code, and come back with the old text if the id is used again). Refuses when some element computes its id: a key that looks unused might be its.',
+    params: [{ name: 'page', type: 'string', positional: true, help: 'only this page (or a shared component: _shared/header, _shared/footer, _shared/<name>); every page by default' }],
+    run: (input, ctx) => {
+        const only = text(input, 'page');
+        const { orphans, dynamicIds } = findOrphanKeys(ctx);
+        if (dynamicIds)
+            throw new OperationError(409, 'dynamic-ids', 'some elements compute their ids in the code, so no key can be said to be unused: remove them by hand if you are sure');
+        const removed = orphans.filter(({ scope }) => only === undefined || scope === only);
+        for (const { scope, keys } of removed)
+            patchJsonFile(ctx, wrPageConfigPath(scope), Object.fromEntries(keys.map(key => [key, null])));
+        return { removed };
+    },
+});
+export const CHECK_OPERATIONS = [projectCheck, issueMute, jsonPrune];
+//# sourceMappingURL=check.js.map

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

@@ -0,0 +1,6 @@
+export declare const commentAdd: import("../define.js").Operation;
+export declare const commentList: import("../define.js").Operation;
+export declare const commentResolve: import("../define.js").Operation;
+export declare const commentDelete: import("../define.js").Operation;
+export declare const COMMENT_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=comments.d.ts.map