mockpit 1.3.0 → 2.0.0

package/dist/server/apiViews.js

@@ -2,7 +2,7 @@
 // one mock reads the same however an agent asks for it.
 import { slotKnobs, slotsInSurfaces } from "./fills.js";
 import { mergeParts, partsInSurfaces } from "./parts.js";
-import { draftedCount, inUseVersion, isSandboxedSurfaceKind, isLive, openCount, SURFACE_CONTENT_FIELDS, } from "./types.js";
+import { draftedCount, inUseVersion, isSandboxedSurfaceKind, isLive, momentsOf, openCount, SURFACE_CONTENT_FIELDS, variantStatus, } from "./types.js";
 export const surfaceRef = (surface, index) => ({
     id: surface.id,
     kind: surface.kind,
@@ -25,6 +25,27 @@ export const hydratedSurfaceView = (surface, index) => {
     delete view[field];
     return view;
 };
+// The still overviews show for a version: its html page's poster.
+const pagePoster = (surfaces) => {
+    const page = surfaces.find((s) => s.kind === "html");
+    return page?.kind === "html" ? page.poster : undefined;
+};
+const posterOf = (surfaces) => {
+    const poster = pagePoster(surfaces);
+    return poster ? { poster } : {};
+};
+// The poster of one version of a variant: what Home shows for it.
+const posterAt = (post, version) => pagePoster((version === post.version
+    ? post.surfaces
+    : post.history.find((h) => h.version === version)?.surfaces) ?? []);
+// The in-use version's poster, when Home shows an older version than the
+// newest.
+const inUsePoster = (p) => {
+    if (p.acceptedVersion === undefined || p.acceptedVersion === p.version)
+        return {};
+    const poster = posterAt(p, p.acceptedVersion);
+    return poster ? { inUsePoster: poster } : {};
+};
 // One past version without its bodies: enough to list versions or pick one to
 // fetch, at a bounded cost.
 export const historyMetaView = (version) => ({
@@ -35,12 +56,13 @@ export const historyMetaView = (version) => ({
     ...(version.prompt ? { prompt: version.prompt } : {}),
     ...(version.author === undefined ? {} : { author: version.author }),
     surfaceKinds: version.surfaces.map((s) => s.kind),
+    ...posterOf(version.surfaces),
 });
 export const variantView = (post, opts = {}) => ({
     postId: post.id,
     state: post.state,
     variant: post.variant,
-    status: post.status,
+    status: variantStatus(post.status),
     version: post.version,
     title: post.title,
     sessionId: post.sessionId,
@@ -49,11 +71,11 @@ export const variantView = (post, opts = {}) => ({
     ...(post.from === undefined ? {} : { from: post.from }),
     ...(post.prompt ? { prompt: post.prompt } : {}),
     ...(post.author === undefined ? {} : { author: post.author }),
-    // A slot is a select knob on its part (fills.ts); declared knobs win.
+    // A part with fills is a select knob on its part (fills.ts); declared knobs win.
     ...(slotsInSurfaces(post.surfaces).length || post.knobs
         ? { knobs: { ...slotKnobs(slotsInSurfaces(post.surfaces)), ...post.knobs } }
         : {}),
-    ...(slotsInSurfaces(post.surfaces).length ? { slots: slotsInSurfaces(post.surfaces) } : {}),
+    ...(slotsInSurfaces(post.surfaces).length ? { fills: slotsInSurfaces(post.surfaces) } : {}),
     ...(post.note ? { note: post.note } : {}),
     // Embedded components as they render now (server/embeds.ts); `publishedWith`
     // is what this version rendered with when it was published.
@@ -63,9 +85,9 @@ export const variantView = (post, opts = {}) => ({
     ...(post.embeds.length ? { publishedWith: post.embeds } : {}),
     ...(post.forkedFrom ? { forkedFrom: post.forkedFrom } : {}),
     ...(post.starred ? { starred: true } : {}),
-    ...(post.acceptedVersion === undefined ? {} : { acceptedVersion: post.acceptedVersion }),
+    ...(post.acceptedVersion === undefined ? {} : { inUseVersion: post.acceptedVersion }),
     // The part names this variant's own markup marks, so the viewer can tell
-    // which looks render a part (Mix) without the html bodies.
+    // which variants render a part (Borrow) without the html bodies.
     parts: partsInSurfaces(post.surfaces).map((p) => p.name),
     surfaces: post.surfaces.map(opts.body ? fullSurfaceView : hydratedSurfaceView),
     ...(opts.history
@@ -101,6 +123,12 @@ export function partsByState(mock, posts) {
             .map((p) => partsInSurfaces(p.surfaces))),
     }));
 }
+// Where a mock sits in the product and the code that implements it, only once
+// declared, so the views of a project that names neither cost nothing.
+export const placeOf = (mock) => ({
+    ...(mock.area ? { area: mock.area } : {}),
+    ...(mock.source ? { source: mock.source } : {}),
+});
 // What Home shows for a mock: the first state's chosen (else first) variant.
 function thumbnail(mock, posts) {
     const first = stateOrder(mock)[0];
@@ -112,8 +140,13 @@ function thumbnail(mock, posts) {
     if (!pick)
         return null;
     const surface = pick.surfaces.findIndex((s) => isSandboxedSurfaceKind(s.kind));
-    return { postId: pick.id, surface: Math.max(surface, 0), version: inUseVersion(pick) };
+    const version = inUseVersion(pick);
+    const poster = posterAt(pick, version);
+    return { postId: pick.id, surface: Math.max(surface, 0), version, ...(poster ? { poster } : {}) };
 }
+// A mock's situations, only once it has any, so the views of mocks without
+// them are unchanged.
+const situationsOf = (mock) => Object.keys(mock.situations).length ? { situations: mock.situations } : {};
 export const mockSummaryView = (mock, posts) => {
     const drafted = draftedCount(mock, posts);
     return {
@@ -122,14 +155,16 @@ export const mockSummaryView = (mock, posts) => {
         slug: mock.slug,
         title: mock.title,
         kind: mock.kind,
+        ...placeOf(mock),
         states: mock.states,
-        stateCount: Math.max(mock.states.length, 1),
+        ...situationsOf(mock),
+        stateCount: Math.max(momentsOf(mock.states, mock.situations).length, 1),
         variants: posts.length,
         open: openCount(mock, posts),
         // Only once the user has started one, so a list with no drafts costs nothing.
         ...(drafted === null ? {} : { drafted }),
         sessionId: mock.sessionId,
-        resolvedAt: mock.resolvedAt,
+        closedAt: mock.closedAt,
         createdAt: mock.createdAt,
         updatedAt: mock.updatedAt,
         thumbnail: thumbnail(mock, posts),
@@ -143,13 +178,15 @@ export const mockDetailView = (mock, posts, opts = {}) => ({
     slug: mock.slug,
     title: mock.title,
     kind: mock.kind,
+    ...placeOf(mock),
     states: mock.states,
+    ...situationsOf(mock),
     asks: mock.asks,
     open: openCount(mock, posts),
     knobs: mock.knobs,
     widths: mock.widths,
     sessionId: mock.sessionId,
-    resolvedAt: mock.resolvedAt,
+    closedAt: mock.closedAt,
     createdAt: mock.createdAt,
     updatedAt: mock.updatedAt,
     variants: posts.map((p) => variantView(p, opts)),
@@ -164,35 +201,39 @@ export const sessionRowView = (session, postCount) => ({
     postCount,
 });
 // One mock as a node of the project tree (GET /api/projects/:name/tree): its
-// variants per state with status and lineage, and the mocks it embeds (`uses`);
-// `usedIn` is filled in once every node is known.
+// variants per state with status and lineage, and the mocks it embeds (`embeds`);
+// `embeddedIn` is filled in once every node is known.
 export const treeNodeView = (mock, posts, extra) => ({
     id: mock.id,
     slug: mock.slug,
     title: mock.title,
     kind: mock.kind,
+    ...placeOf(mock),
     open: openCount(mock, posts),
-    states: mock.states.length ? mock.states : [null],
+    // Home shows a mock's states, never their situations.
+    states: mock.states.length ? momentsOf(mock.states, mock.situations) : [null],
     widths: mock.widths,
     createdAt: mock.createdAt,
     updatedAt: mock.updatedAt,
-    resolvedAt: mock.resolvedAt,
+    closedAt: mock.closedAt,
     settled: extra.settled,
-    uses: extra.uses,
-    usedIn: [],
+    embeds: extra.embeds,
+    embeddedIn: [],
     inUse: inUseByState(mock, posts),
     variants: posts.map((p) => ({
         postId: p.id,
         state: p.state,
         variant: p.variant,
-        status: p.status,
+        status: variantStatus(p.status),
         version: p.version,
         updatedAt: p.updatedAt,
         surface: p.surfaces.findIndex((x) => isSandboxedSurfaceKind(x.kind)),
+        ...posterOf(p.surfaces),
+        ...inUsePoster(p),
         ...(p.note ? { note: p.note } : {}),
         ...(p.forkedFrom ? { forkedFrom: p.forkedFrom } : {}),
         ...(p.starred ? { starred: true } : {}),
-        ...(p.acceptedVersion === undefined ? {} : { acceptedVersion: p.acceptedVersion }),
-        ...(extra.embeds.get(p.id) ? { embedsKey: extra.embeds.get(p.id).key } : {}),
+        ...(p.acceptedVersion === undefined ? {} : { inUseVersion: p.acceptedVersion }),
+        ...(extra.embedViews.get(p.id) ? { embedsKey: extra.embedViews.get(p.id).key } : {}),
     })),
 });

package/dist/server/app.d.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { type FeedEvent } from "./events.ts";
 import { type GuideTopic } from "./designGuide.ts";
+import { type GuidePack } from "./guidance.ts";
 import { type Executor, type RunLimits } from "./run.ts";
 import { type LogSink } from "./eventLog.ts";
 import { type Store } from "./types.ts";
@@ -14,6 +15,8 @@ export interface AppOptions {
     viewerHtml: string;
     setupText: string;
     topics?: Partial<Record<GuideTopic, string>>;
+    packs?: Partial<Record<GuidePack, string>>;
+    userRules?: () => Promise<string | null>;
     authenticate?: AuthenticateHook;
     authToken?: string;
     basePath?: BasePathHook;
@@ -53,4 +56,4 @@ export interface FlowContext {
     request?: Request;
     signal?: AbortSignal;
 }
-export declare function createApp({ store, viewerHtml, setupText, topics, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, renderRev, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export declare function createApp({ store, viewerHtml, setupText, topics, packs, userRules, authenticate, authToken, basePath, publicRead, screenshots, version, upgradeCommand, renderRev, fetchLatestRelease, onEvent, maxHoldConnections, executor, runLimits, log, }: AppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;