@webround/editor 0.0.0-stage → 0.3.0

package/dist/operations/ops/pages.js

@@ -0,0 +1,154 @@
+import fs from 'fs';
+import path from 'path';
+import { wrPageConfigPath, wrPageFilePath } from '@webround/core/routing';
+import { defineOperation, flag, invalid, OperationError, text } from '../define.js';
+import { isSafeComponentName, isSafePageName } from '../context.js';
+import { dropScopeComments, renameScopeComments } from '../comments-store.js';
+import { ROUTES_FILE, readRoutes } from './project.js';
+/** The file a new page starts as. */
+export function wrPageScaffold(component) {
+    return `import { WrSection } from '@webround/core';
+
+export default function ${component}() {
+    return <WrSection id="root" />;
+}
+`;
+}
+const writeRoutes = (srcRoot, routes) => fs.writeFileSync(path.join(srcRoot, ROUTES_FILE), JSON.stringify(routes, null, 2));
+export const pageList = defineOperation({
+    name: 'page-list',
+    readOnly: true,
+    summary: 'The pages of the site: name, component, and whether the shared header and footer are shown on each.',
+    run: (_input, ctx) => ({
+        pages: Object.entries(readRoutes(ctx)).map(([pageName, entry]) => ({
+            pageName,
+            component: entry.component,
+            lazy: entry.lazy,
+            // Shown unless the page says otherwise (see core/routing)
+            header: entry.header !== false,
+            footer: entry.footer !== false,
+        })),
+    }),
+});
+export const pageCreate = defineOperation({
+    name: 'page-create',
+    summary: 'Creates a page: its component, its (empty) JSON of values and its entry in the routes.',
+    params: [
+        { name: 'pageName', type: 'string', positional: true, required: true, help: 'the page name: it is the URL (letters, digits, - and _)' },
+        { name: 'component', type: 'string', required: true, help: 'the name of its component, e.g. About (a file in src/pages/)' },
+        { name: 'lazy', type: 'boolean', default: false, help: 'load the page only when it is visited' },
+    ],
+    run: (input, ctx) => {
+        const pageName = text(input, 'pageName');
+        const component = text(input, 'component');
+        if (!isSafePageName(pageName) || !isSafeComponentName(component))
+            throw invalid('invalid pageName or component');
+        const lazy = flag(input, 'lazy');
+        const pagePath = path.join(ctx.srcRoot, wrPageConfigPath(pageName));
+        const componentPath = path.join(ctx.srcRoot, wrPageFilePath(component));
+        if (fs.existsSync(pagePath) || fs.existsSync(componentPath))
+            throw new OperationError(409, 'page-exists', 'page or component already exists');
+        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 = readRoutes(ctx);
+        routes[pageName] = { component, ...(lazy ? { lazy: true } : {}) };
+        writeRoutes(ctx.srcRoot, routes);
+        return { pageName };
+    },
+});
+export const pageDelete = defineOperation({
+    name: 'page-delete',
+    destructive: true,
+    summary: 'Deletes a page: its component, its JSON of values, its comments and its entry in the routes.',
+    params: [{ name: 'pageName', type: 'string', positional: true, required: true, help: 'the page to delete' }],
+    run: (input, ctx) => {
+        const pageName = text(input, 'pageName');
+        if (!isSafePageName(pageName))
+            throw invalid('invalid pageName');
+        const routes = readRoutes(ctx);
+        const entry = routes[pageName];
+        if (!entry)
+            throw new OperationError(404, 'page-not-found', 'page not found');
+        if (!isSafeComponentName(entry.component))
+            throw new OperationError(500, 'invalid-routes', 'invalid component in routes.json');
+        const pagePath = path.join(ctx.srcRoot, wrPageConfigPath(pageName));
+        const componentPath = path.join(ctx.srcRoot, wrPageFilePath(entry.component));
+        if (fs.existsSync(pagePath))
+            fs.unlinkSync(pagePath);
+        if (fs.existsSync(componentPath))
+            fs.unlinkSync(componentPath);
+        delete routes[pageName];
+        writeRoutes(ctx.srcRoot, routes);
+        dropScopeComments(ctx, pageName);
+        return { pageName };
+    },
+});
+export const pageUpdate = defineOperation({
+    name: 'page-update',
+    summary: 'Changes a page: renames it or its component, loads it lazily or not, shows or hides the shared header and footer on it.',
+    params: [
+        { name: 'pageName', type: 'string', positional: true, required: true, help: 'the page' },
+        { name: 'newPageName', type: 'string', help: 'a new name (its JSON of values moves with it)' },
+        { name: 'newComponent', type: 'string', help: 'a new component name (its file moves with it)' },
+        { name: 'lazy', type: 'boolean', help: 'load the page only when it is visited' },
+        { name: 'header', type: 'boolean', help: 'show the shared header on this page' },
+        { name: 'footer', type: 'boolean', help: 'show the shared footer on this page' },
+    ],
+    run: (input, ctx) => {
+        const pageName = text(input, 'pageName');
+        if (!isSafePageName(pageName))
+            throw invalid('invalid pageName');
+        const routes = readRoutes(ctx);
+        const entry = routes[pageName];
+        if (!entry)
+            throw new OperationError(404, 'page-not-found', 'page not found');
+        if (!isSafeComponentName(entry.component))
+            throw new OperationError(500, 'invalid-routes', 'invalid component in routes.json');
+        const finalPageName = text(input, 'newPageName') ?? pageName;
+        const finalComponent = text(input, 'newComponent') ?? entry.component;
+        if (!isSafePageName(finalPageName) || !isSafeComponentName(finalComponent))
+            throw invalid('invalid newPageName or newComponent');
+        if (finalPageName !== pageName && routes[finalPageName])
+            throw new OperationError(409, 'page-exists', 'target page name already exists');
+        const pagePath = path.join(ctx.srcRoot, wrPageConfigPath(pageName));
+        const componentPath = path.join(ctx.srcRoot, wrPageFilePath(entry.component));
+        const newPagePath = path.join(ctx.srcRoot, wrPageConfigPath(finalPageName));
+        const newComponentPath = path.join(ctx.srcRoot, wrPageFilePath(finalComponent));
+        if (fs.existsSync(pagePath) && pagePath !== newPagePath) {
+            fs.mkdirSync(path.dirname(newPagePath), { recursive: true });
+            fs.renameSync(pagePath, newPagePath);
+        }
+        if (fs.existsSync(componentPath) && componentPath !== newComponentPath) {
+            fs.mkdirSync(path.dirname(newComponentPath), { recursive: true });
+            fs.renameSync(componentPath, newComponentPath);
+        }
+        delete routes[pageName];
+        // The entry is kept (header/footer and whatever comes next): only what the request says changes. `true` is the default of
+        // header and footer and is not written.
+        const next = { ...entry, component: finalComponent };
+        const lazy = flag(input, 'lazy');
+        if (lazy !== undefined) {
+            if (lazy)
+                next.lazy = true;
+            else
+                delete next.lazy;
+        }
+        for (const key of ['header', 'footer']) {
+            const value = flag(input, key);
+            if (value === undefined)
+                continue;
+            if (value === false)
+                next[key] = false;
+            else
+                delete next[key];
+        }
+        routes[finalPageName] = next;
+        writeRoutes(ctx.srcRoot, routes);
+        renameScopeComments(ctx, pageName, finalPageName);
+        return { pageName: finalPageName };
+    },
+});
+export const PAGE_OPERATIONS = [pageList, pageCreate, pageDelete, pageUpdate];
+//# sourceMappingURL=pages.js.map

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

@@ -0,0 +1,36 @@
+import { type WrLangConfig, type WrRoutesFile, type WrSharedScope } from '@webround/core/routing';
+import type { WrSeoSite } from '@webround/core/seo';
+import { type OperationContext } from '../define.js';
+/** A page, or a shared component (the header, the footer, a card): the file of its code and the JSON of its values (both relative to `src/`). */
+export interface ScopeFiles {
+    name: string;
+    file: string;
+    json: string;
+}
+export declare function readJsonFile<T = unknown>(ctx: OperationContext, relative: string): T | null;
+/** Merges `patch` into a JSON file (created if missing): a `null` value removes the key. */
+export declare function patchJsonFile(ctx: OperationContext, relative: string, patch: Record<string, unknown>): void;
+export declare const ROUTES_FILE = "config/routes.json";
+export declare const LANGS_FILE = "config/langs.json";
+export declare const SEO_FILE = "config/seo.json";
+export declare function readRoutes(ctx: OperationContext): WrRoutesFile;
+/** Every shared scope of the project: its header and footer, and the shared components it declares in `config/shared.json`. THE list. */
+export declare const sharedScopesOf: (ctx: OperationContext) => WrSharedScope[];
+export declare const readSeoSite: (ctx: OperationContext) => WrSeoSite;
+/**
+ * The key a language has in the JSON: `default` for the site's default language (also when it is asked for by its code), the code for the
+ * others. THE way an operation turns a `lang` parameter into where a translation is written: a language the site does not have is refused
+ * (a typo must not create a stray key in the JSON).
+ */
+export declare function langKeyOf(ctx: OperationContext, requested: string | undefined): string;
+export declare const readLangs: (ctx: OperationContext) => WrLangConfig | null;
+/** The files of a page by its name (`home`), or of a shared component by its (`_shared/header`, `_shared/product-card`). */
+export declare function scopeFilesOf(ctx: OperationContext, page: string): ScopeFiles;
+/** Every scope a visitor sees on a page: its header, the page and its footer, in the order they are on the page. */
+export declare function scopesOfPage(ctx: OperationContext, page: string): ScopeFiles[];
+/**
+ * Which scope an operation means: by `page` (a name) for a caller that knows the site by its pages, or by `file` (the code file, relative
+ * to `src/`) for the editor's own page, which already knows it. Exactly one of the two.
+ */
+export declare function scopeOfInput(ctx: OperationContext, input: Record<string, unknown>): ScopeFiles;
+//# sourceMappingURL=project.d.ts.map

package/dist/operations/ops/project.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import { WR_SHARED_FILE, WR_SHARED_SCOPES, wrLangKey, wrPageConfigPath, wrPageFilePath, wrSharedScopes } from '@webround/core/routing';
+import { OperationError } from '../define.js';
+import { isSafePageName } from '../context.js';
+export function readJsonFile(ctx, relative) {
+    const file = ctx.resolveInSrc(relative);
+    if (!file || !fs.existsSync(file))
+        return null;
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+}
+/** Merges `patch` into a JSON file (created if missing): a `null` value removes the key. */
+export function patchJsonFile(ctx, relative, patch) {
+    const file = ctx.resolveInSrc(relative);
+    if (!file)
+        throw new OperationError(400, 'invalid-file', 'invalid file path');
+    const current = (fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf-8')) : {});
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null)
+            delete current[key];
+        else
+            current[key] = value;
+    }
+    fs.writeFileSync(file, JSON.stringify(current, null, 2));
+}
+export const ROUTES_FILE = 'config/routes.json';
+export const LANGS_FILE = 'config/langs.json';
+export const SEO_FILE = 'config/seo.json';
+export function readRoutes(ctx) {
+    return readJsonFile(ctx, ROUTES_FILE) ?? {};
+}
+/** Every shared scope of the project: its header and footer, and the shared components it declares in `config/shared.json`. THE list. */
+export const sharedScopesOf = (ctx) => wrSharedScopes(readJsonFile(ctx, WR_SHARED_FILE));
+export const readSeoSite = (ctx) => readJsonFile(ctx, SEO_FILE) ?? {};
+/**
+ * The key a language has in the JSON: `default` for the site's default language (also when it is asked for by its code), the code for the
+ * others. THE way an operation turns a `lang` parameter into where a translation is written: a language the site does not have is refused
+ * (a typo must not create a stray key in the JSON).
+ */
+export function langKeyOf(ctx, requested) {
+    const langs = readLangs(ctx);
+    const lang = requested ?? 'default';
+    if (lang === 'default')
+        return 'default';
+    if (!langs)
+        throw new OperationError(400, 'invalid-language', 'the site is not multilingual: there is only the default language');
+    if (!langs.available.includes(lang))
+        throw new OperationError(400, 'invalid-language', `"${lang}" is not a language of the site (${langs.available.join(', ')})`);
+    return wrLangKey(lang, langs);
+}
+export const readLangs = (ctx) => readJsonFile(ctx, LANGS_FILE);
+/** The files of a page by its name (`home`), or of a shared component by its (`_shared/header`, `_shared/product-card`). */
+export function scopeFilesOf(ctx, page) {
+    const shared = sharedScopesOf(ctx).find(scope => scope.name === page);
+    if (shared)
+        return { name: shared.name, file: shared.file, json: wrPageConfigPath(shared.name) };
+    if (!isSafePageName(page))
+        throw new OperationError(400, 'invalid-page', `invalid page name "${page}"`);
+    const entry = readRoutes(ctx)[page];
+    if (!entry)
+        throw new OperationError(404, 'page-not-found', `no page called "${page}"`);
+    return { name: page, file: wrPageFilePath(entry.component), json: wrPageConfigPath(page) };
+}
+/** Every scope a visitor sees on a page: its header, the page and its footer, in the order they are on the page. */
+export function scopesOfPage(ctx, page) {
+    const entry = readRoutes(ctx)[page];
+    if (!entry)
+        throw new OperationError(404, 'page-not-found', `no page called "${page}"`);
+    return [
+        ...(entry.header !== false ? [scopeFilesOf(ctx, WR_SHARED_SCOPES.header.name)] : []),
+        scopeFilesOf(ctx, page),
+        ...(entry.footer !== false ? [scopeFilesOf(ctx, WR_SHARED_SCOPES.footer.name)] : []),
+    ];
+}
+/**
+ * Which scope an operation means: by `page` (a name) for a caller that knows the site by its pages, or by `file` (the code file, relative
+ * to `src/`) for the editor's own page, which already knows it. Exactly one of the two.
+ */
+export function scopeOfInput(ctx, input) {
+    const { page, file } = input;
+    if (typeof page === 'string' && page)
+        return scopeFilesOf(ctx, page);
+    if (typeof file === 'string' && file) {
+        if (!ctx.resolveInSrc(file))
+            throw new OperationError(400, 'invalid-file', 'invalid file');
+        // The JSON of a file: the page that uses it, or the shared scope it belongs to
+        const shared = sharedScopesOf(ctx).find(scope => scope.file === file);
+        if (shared)
+            return { name: shared.name, file, json: wrPageConfigPath(shared.name) };
+        const routes = readRoutes(ctx);
+        const name = Object.keys(routes).find(key => wrPageFilePath(routes[key].component) === file);
+        return { name: name ?? file, file, json: wrPageConfigPath(name ?? file) };
+    }
+    throw new OperationError(400, 'invalid-input', 'page (or file) required');
+}
+//# sourceMappingURL=project.js.map

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

@@ -0,0 +1,17 @@
+import { type OperationContext } from '../define.js';
+/**
+ * Writes robots.txt and the sitemaps into `public/` (only what changed). Nothing is written while the site does not know its public address.
+ * ONE function: the dev server's watcher calls it whenever pages, languages or SEO data change, `seo-sync` calls it on demand.
+ */
+export declare function writeSeoFiles(ctx: OperationContext): {
+    written: string[];
+    reason?: 'no-site-url';
+};
+export declare const seoGet: import("../define.js").Operation;
+export declare const seoSuggest: import("../define.js").Operation;
+export declare const seoSet: import("../define.js").Operation;
+export declare const seoSiteSet: import("../define.js").Operation;
+export declare const seoSync: import("../define.js").Operation;
+export declare const seoSnapshotTargets: import("../define.js").Operation;
+export declare const SEO_OPERATIONS: import("../define.js").Operation[];
+//# sourceMappingURL=seo.d.ts.map