@mosetta/editor 0.0.33 → 0.0.35

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mosetta/editor
 
+## 0.0.35
+
+- Built with the framework 0.0.13: a block's server action is told the block it is called from —
+  its settings as the page stores them, read by the host — so a form's server side can trust what
+  the site's author set on it (the hours a booking form offers).
+
+## 0.0.34
+
+- A new page starts from the site's page preset: the prefab `pagePreset` — the blocks every page of
+  the site begins with, and an `outlet` block where the page's own go. The preset is copied into the
+  page; a site without one starts its pages in the frame of its home page. "Create a page" and the
+  content API's `createPage` (with `preset: true`) both do it. The page preset may hold prefabs.
+
 ## 0.0.33
 
 - The assistant's chat lets the person choose the model it works with, among the ones the platform

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mosetta/editor",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "license": "MIT",
   "description": "mosetta visual editor tile palette: block picker, page tree, inspector, isolated draft preview and the content API behind them.",
   "repository": {
@@ -14,15 +14,15 @@
   "dependencies": {
     "react": "*",
     "react-dom": "*",
-    "@mosetta/content": "0.0.12",
-    "@mosetta/core": "0.0.12",
-    "@mosetta/di": "0.0.12",
-    "@mosetta/runtime": "0.0.12",
-    "@mosetta/stores": "0.0.12",
-    "@mosetta/server-action": "0.0.12",
-    "@mosetta/settings": "0.0.12",
-    "@mosetta/ui": "0.0.12",
-    "@mosetta/react": "0.0.12"
+    "@mosetta/content": "0.0.13",
+    "@mosetta/di": "0.0.13",
+    "@mosetta/react": "0.0.13",
+    "@mosetta/settings": "0.0.13",
+    "@mosetta/runtime": "0.0.13",
+    "@mosetta/core": "0.0.13",
+    "@mosetta/stores": "0.0.13",
+    "@mosetta/server-action": "0.0.13",
+    "@mosetta/ui": "0.0.13"
   },
   "devDependencies": {
     "@types/react": "*",

package/tiles/content/content.server.ts

@@ -42,6 +42,8 @@ import type { ZodType } from 'zod';
 import { projectNamespaceOf, unitOf } from '@mosetta/content';
 import type { IContentTransport } from '@mosetta/content';
 import { CONFIG_PATH } from '@mosetta/content/paths';
+import { homeFrameOf, PAGE_PRESET, startedPage } from './pagePreset';
+import type { TPageStart } from './pagePreset';
 import { blockSchemas, settingsIssueLine, treeSettingsIssues } from '@mosetta/settings/check';
 import type { ICatalogSettingsEntry } from '@mosetta/settings/check';
 import {
@@ -194,11 +196,14 @@ function pageReferences(page: IPageDoc): string[] {
 /**
  * A tree's references checked the way each kind exists: a module against the catalog; a live
  * PREFAB is content (the project's) or the distribution's and never in the catalog — a missing one
- * renders the node's children without it. Inside a prefab a prefab is refused: one level only.
+ * renders the node's children without it. Inside a prefab a prefab is refused: one level only —
+ * except in the site's page preset, which is never placed but copied into a new page, its prefabs
+ * becoming the page's own (pagePreset.ts).
  */
-function referenceIssues(refs: readonly string[], known: ReadonlySet<string>, kind: ContentKind): string[] {
+function referenceIssues(refs: readonly string[], known: ReadonlySet<string>, kind: ContentKind, name: string): string[] {
+  const holdsPrefabs = kind === 'pages' || name === PAGE_PRESET;
   return refs.flatMap((ref) => {
-    if (unitOf(ref) !== null) return kind === 'prefabs' ? [`a prefab cannot hold a prefab: ${ref}`] : [];
+    if (unitOf(ref) !== null) return holdsPrefabs ? [] : [`a prefab cannot hold a prefab: ${ref}`];
     return known.has(ref) ? [] : [`unknown tile reference: ${ref}`];
   });
 }
@@ -325,20 +330,43 @@ class LoadPageDraftAction extends ContentAction<TDraftInput, { draft: ILoadedDra
   }
 }
 
-type TPageInput = { name: string; page: IPageDoc } & IKindInput;
+type TPageInput = { name: string; page: IPageDoc; preset?: boolean } & IKindInput;
 
 @DiServerAction(createPageToken)
-class CreatePageAction extends ContentAction<TPageInput, { draftId: string }> {
+class CreatePageAction extends ContentAction<TPageInput, { draftId: string; started?: TPageStart }> {
   constructor(@DiInject(CONTENT_REPOSITORY_TOKEN) private readonly content: ContentRepository) {
     super();
   }
 
   protected inputSchema(builder: ICreateSchema['builder'], s: ContentSchemas) {
-    return builder.object({ name: s.entityName, page: s.pageDoc, kind: s.contentKind.optional() }) as unknown as ZodType<TPageInput>;
+    return builder.object({ name: s.entityName, page: s.pageDoc, preset: builder.boolean().optional(), kind: s.contentKind.optional() }) as unknown as ZodType<TPageInput>;
   }
 
-  protected async run({ name, page, kind = 'pages' }: TPageInput) {
-    return { draftId: await this.content.create(kind, name, storedFormOf(kind, page), kind === 'prefabs' ? 'unit' : undefined) };
+  // with `preset`, a page starts as the site's pages do (pagePreset.ts): its blocks go into the
+  // site's page preset, or into its home page's frame
+  protected async run({ name, page, preset = false, kind = 'pages' }: TPageInput) {
+    const start = preset && kind === 'pages' ? await this.startOf() : null;
+    const placed = start ? startedPage(start.blocks, page.children ?? []) : null;
+    const made = placed?.started ? { ...page, children: placed.children } : page;
+    const draftId = await this.content.create(kind, name, storedFormOf(kind, made), kind === 'prefabs' ? 'unit' : undefined);
+    return { draftId, ...(placed?.started ? { started: start!.from } : {}) };
+  }
+
+  /** what a new page of this site starts with: its preset, else its home page's frame; null — neither */
+  private async startOf(): Promise<{ from: TPageStart; blocks: IBlueprintNodeDoc[] } | null> {
+    const published = async (kind: ContentKind, name: string): Promise<IPageDoc | null> => {
+      try {
+        return editedFormOf(kind, (await this.content.load<unknown>(kind, name)).doc);
+      } catch (e) {
+        if (e instanceof ContentError) return null;
+        throw e;
+      }
+    };
+    const preset = await published('prefabs', PAGE_PRESET);
+    if (preset) return { from: 'pagePreset', blocks: preset.children ?? [] };
+    const home = await published('pages', 'home');
+    const frame = home ? homeFrameOf(home.children ?? []) : [];
+    return frame.length ? { from: 'home', blocks: frame } : null;
   }
 }
 
@@ -367,7 +395,7 @@ class SavePageDraftAction extends ContentAction<TSaveInput, { warnings: string[]
   // NOT soft: a page whose seq does not follow the stored draft's comes back as CONFLICT.
   protected async run({ name, draftId, page, kind = 'pages' }: TSaveInput) {
     const known = await this.catalog.knownReferences();
-    const warnings = referenceIssues(pageReferences(page), known, kind);
+    const warnings = referenceIssues(pageReferences(page), known, kind, name);
     await this.content.saveDraft(kind, name, draftId, storedFormOf(kind, page));
     return { warnings };
   }
@@ -450,7 +478,7 @@ class PublishPageAction extends ContentAction<TPublishInput, { live: number }> {
     const known = new Set(descriptors.map((d) => d.id));
     const edited = editedFormOf(kind, doc);
     const refs = pageReferences(edited);
-    issues.push(...referenceIssues(refs, known, kind));
+    issues.push(...referenceIssues(refs, known, kind, name));
     issues.push(...treeSettingsIssues(edited, blockSchemas(descriptors as readonly ICatalogSettingsEntry[])).map(settingsIssueLine));
 
     if (kind === 'pages') {

package/tiles/content/contentCommon.ts

@@ -63,9 +63,13 @@ export const loadPageDraftToken = new ServerActionToken<
   ContentActionResult<{ draft: ILoadedDraft<IPageDoc> }>
 >({ actionName: 'loadPageDraft', serverModuleName: 'content', tags: ['pages'] });
 
+/**
+ * A new page or prefab. With `preset`, a page starts as the site's pages do: its blocks inside the
+ * site's page preset (or its home page's frame) — `started` says which, when either was used.
+ */
 export const createPageToken = new ServerActionToken<
-  { name: string; page: IPageDoc } & IKindInput,
-  ContentActionResult<{ draftId: string }>
+  { name: string; page: IPageDoc; preset?: boolean } & IKindInput,
+  ContentActionResult<{ draftId: string; started?: 'pagePreset' | 'home' }>
 >({ actionName: 'createPage', serverModuleName: 'content', invalidates: ['pages'] });
 
 export const savePageDraftToken = new ServerActionToken<

package/tiles/content/pagePreset.ts

@@ -0,0 +1,81 @@
+// A NEW PAGE STARTS FROM THE SITE'S PAGE PRESET: the prefab `pagePreset` — the blocks every new page
+// of the site begins with (its theme, its translations, a sign-in wrapper, whatever the site wants
+// on all of its pages), and an OUTLET block where the page's own blocks go. A site without one starts
+// its pages in the frame of its home page: the prefabs that page is built in, one inside the other.
+// The preset is COPIED into the page, not referenced: changing it changes the pages made after,
+// never the ones made before. One rule for every way a page is made — the editor's Create, the
+// assistant's create_page — so no author has to remember what a page of this site needs.
+import type { IBlueprintNodeDoc } from '@mosetta/content';
+import { isOutletReference, unitOf } from '@mosetta/content/units';
+
+/** the prefab a site names its page preset by */
+export const PAGE_PRESET = 'pagePreset';
+
+/** where a new page's start came from: the site's preset, or its home page's frame */
+export type TPageStart = 'pagePreset' | 'home';
+
+type TNode = IBlueprintNodeDoc;
+
+const idsIn = (nodes: readonly TNode[]): string[] => nodes.flatMap((node) => [node.id, ...idsIn(node.children ?? [])]);
+
+/**
+ * The frame of a home page: its blocks while they are one prefab inside another, outermost first,
+ * each without the page's own blocks — none when the page's blocks are not one prefab.
+ */
+export function homeFrameOf(home: readonly TNode[]): TNode[] {
+  const chain: TNode[] = [];
+  for (let level = home; level.length === 1 && unitOf(level[0].reference); level = level[0].children ?? []) chain.push(level[0]);
+  return chain.reduceRight<TNode[]>((inner, { children: _children, ...node }) => [{ ...node, children: inner }], []);
+}
+
+/** the first outlet of a tree in document order, as the path of child indexes leading to it */
+function outletPath(nodes: readonly TNode[]): number[] | null {
+  for (let i = 0; i < nodes.length; i++) {
+    if (isOutletReference(nodes[i].reference)) return [i];
+    const below = outletPath(nodes[i].children ?? []);
+    if (below) return [i, ...below];
+  }
+  return null;
+}
+
+/** the tree with the node at `path` replaced by `content` */
+function replacedAt(nodes: readonly TNode[], path: readonly number[], content: readonly TNode[]): TNode[] {
+  const [at, ...rest] = path;
+  if (!rest.length) return [...nodes.slice(0, at), ...content, ...nodes.slice(at + 1)];
+  return nodes.map((node, i) => (i === at ? { ...node, children: replacedAt(node.children ?? [], rest, content) } : node));
+}
+
+/** the tree with `content` added to its innermost block while the blocks are one inside another */
+function appendedInside(nodes: readonly TNode[], content: readonly TNode[]): TNode[] {
+  if (nodes.length !== 1) return [...nodes, ...content];
+  const [only] = nodes;
+  const children = only.children ?? [];
+  return [{ ...only, children: children.length === 1 ? appendedInside(children, content) : [...children, ...content] }];
+}
+
+/** the start's blocks renamed where the page's own blocks already have an id: the page's ids stay */
+function withFreeIds(nodes: readonly TNode[], taken: Set<string>): TNode[] {
+  return nodes.map((node) => {
+    let id = node.id;
+    if (taken.has(id)) {
+      let n = 1;
+      while (taken.has(`${node.id}-preset${n > 1 ? n : ''}`)) n++;
+      id = `${node.id}-preset${n > 1 ? n : ''}`;
+    }
+    taken.add(id);
+    return { ...node, id, children: withFreeIds(node.children ?? [], taken) };
+  });
+}
+
+/**
+ * A new page's blocks: the start's (a copy) with the page's own `content` in its outlet — or, with
+ * no outlet, inside its innermost block. Content that already begins with a prefab of the start's
+ * (its author built the frame) is taken as it is; so is everything when the start is empty.
+ */
+export function startedPage(start: readonly TNode[], content: readonly TNode[]): { children: TNode[]; started: boolean } {
+  const startPrefabs = new Set(start.map((node) => node.reference).filter((reference) => unitOf(reference)));
+  if (!start.length || content.some((node) => startPrefabs.has(node.reference))) return { children: [...content], started: false };
+  const copy = withFreeIds(structuredClone(start), new Set(idsIn(content)));
+  const path = outletPath(copy);
+  return { children: path ? replacedAt(copy, path, content) : appendedInside(copy, content), started: true };
+}

package/tiles/pagesPanel/pagesPanel.component.tsx

@@ -1216,7 +1216,8 @@ function CreateModal({ routes, own, onClose, onJump, onCreated }: ICreateModalPr
   const submit = (): void => {
     if (!name || create.isLoading()) return;
     createdRef.current = name;
-    create.start!({ name, page: { id: name, reference: rootId, pattern: byName ? PREFAB_CANVAS_PATTERN : trimmed, children: [] }, kind });
+    // a page starts as the site's pages do — in its page preset (or its home page's frame)
+    create.start!({ name, page: { id: name, reference: rootId, pattern: byName ? PREFAB_CANVAS_PATTERN : trimmed, children: [] }, kind, ...(byName ? {} : { preset: true }) });
   };
 
   return (