@newt-kit/plan 0.0.0-stage → 0.10.0

package/render/page-data.ts

@@ -0,0 +1,89 @@
+import type { AppMap } from '../map/app-map'
+import type { Check, StepState } from '../plan/compare'
+import type { PlanInput } from '../plan/plan.schema'
+import type { ResolvedPlan, Status } from '../plan/resolve'
+
+const MODULE_STATUS: Record<Status, string> = { new: 'new', modified: 'mod', consumed: 'use', unchanged: 'old', removed: 'del' }
+const PIECE_STATUS: Record<Status, string> = { new: 'n', modified: 'm', consumed: 'u', unchanged: 'o', removed: 'x' }
+const RELATION_STATUS = { new: 'n', unchanged: 'o', removed: 'x' } as const
+const PIECE_KIND = { useCase: 'uc', event: 'ev', schedule: 'sch' } as const
+const RELATION_KIND = { emits: 'emit', triggers: 'ev', calls: 'call' } as const
+const PIECE_ID = /\{([a-z][\w-]*\/[a-zA-Z]\w*\.[a-zA-Z]\w*)\}/g
+
+export type PageStep = { title: string, text?: string, focus: string[], state?: StepState, done?: number, of?: number }
+
+/** The page's data, as its script reads it (see the comment that opens it). */
+export type PageData = {
+  language: ResolvedPlan['language']
+  mode: ResolvedPlan['mode']
+  title: string
+  subtitle?: string
+  contexts: Record<string, string>
+  modules: Record<string, { ctx: string, port: boolean, st: string, why?: string, items: [string, string, string, { why?: string, cron?: string }][] }>
+  relations: [string, string, string, string, string, string, boolean][]
+  steps: PageStep[]
+  rules: { ok: boolean, text: string }[]
+  /** A review held against a plan: each thing done or not. */
+  checks?: Check[]
+  /** A plan's page: the plan, for its button to save. */
+  plan?: PlanInput
+  /** A review's page: both maps, for a plan loaded in the page to be held against them. */
+  maps?: { base: AppMap, head: AppMap }
+}
+
+export type PageExtras = {
+  steps?: { title: string, text?: string, focus: string[], state?: StepState, done?: number, of?: number }[]
+  checks?: Check[]
+  plan?: PlanInput
+  maps?: { base: AppMap, head: AppMap }
+}
+
+/**
+ * The page's data: a module is named by its name, or `<context>/<name>` where two
+ * contexts have one of the same name, and a piece by its module's key and its name.
+ */
+export function pageData(plan: ResolvedPlan, extras: PageExtras = {}): PageData {
+  const named = new Map<string, number>()
+  for (const module of plan.modules) {
+    named.set(module.name, (named.get(module.name) ?? 0) + 1)
+  }
+  const keyOf = new Map(plan.modules.map(module => [module.id, named.get(module.name)! > 1 ? module.id : module.name]))
+  const pieceKey = (id: string) => keyOf.has(id.slice(0, id.indexOf('.'))) ? `${keyOf.get(id.slice(0, id.indexOf('.')))}.${id.slice(id.indexOf('.') + 1)}` : id
+  const inText = (text: string) => text.replace(PIECE_ID, (_, id: string) => `{${pieceKey(id)}}`)
+
+  const modules: PageData['modules'] = {}
+  for (const module of plan.modules) {
+    modules[keyOf.get(module.id)!] = {
+      ctx: module.context,
+      port: module.port,
+      st: MODULE_STATUS[module.status],
+      ...(module.why ? { why: module.why } : {}),
+      items: module.pieces.map(piece => [piece.name, PIECE_KIND[piece.kind], PIECE_STATUS[piece.status], {
+        ...(piece.why ? { why: piece.why } : {}),
+        ...(piece.cron ? { cron: piece.cron } : {}),
+      }]),
+    }
+  }
+  return {
+    language: plan.language,
+    mode: plan.mode,
+    title: plan.title,
+    ...(plan.subtitle ? { subtitle: plan.subtitle } : {}),
+    contexts: Object.fromEntries(plan.contexts.filter(context => plan.modules.some(module => module.context === context.name)).map(context => [context.name, context.name])),
+    modules,
+    relations: plan.relations.map(relation => [
+      RELATION_KIND[relation.kind], pieceKey(relation.from), pieceKey(relation.to), RELATION_STATUS[relation.status],
+      relation.why ?? '', relation.queue ?? '', relation.conditional ?? false,
+    ]),
+    steps: (extras.steps ?? plan.steps).map(step => ({
+      ...step,
+      title: inText(step.title),
+      ...(step.text ? { text: inText(step.text) } : {}),
+      focus: step.focus.map(pieceKey),
+    })),
+    rules: plan.rules,
+    ...(extras.checks ? { checks: extras.checks } : {}),
+    ...(extras.plan ? { plan: extras.plan } : {}),
+    ...(extras.maps ? { maps: extras.maps } : {}),
+  }
+}

package/render/render.ts

@@ -0,0 +1,38 @@
+import { join } from 'node:path'
+import type { PageData } from './page-data'
+
+export const TEMPLATE = join(import.meta.dir, 'template.html')
+const BROWSER = join(import.meta.dir, 'browser.ts')
+
+/** As JSON in a script: nothing in it may close the script or open a comment. */
+const inScript = (value: unknown) => JSON.stringify(value).replace(/[<\u2028\u2029]/g, char => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
+
+/** The review the page runs on a plan loaded in it, bundled for the browser once. */
+let bundle: Promise<string> | undefined
+function reviewScript(): Promise<string> {
+  bundle ??= Bun.build({ entrypoints: [BROWSER], target: 'browser', format: 'iife', minify: true }).then(async built => {
+    if (!built.success) {
+      throw new AggregateError(built.logs, 'The page\'s review script does not build')
+    }
+    return (await built.outputs[0]!.text()).replace(/<\/script/gi, '<\\/script')
+  })
+  return bundle
+}
+
+/**
+ * The page: the template, always the same, with the data in it, and for a review the
+ * script that holds it against a plan loaded in the page. The same data gives the same bytes.
+ */
+export async function renderPage(data: PageData, template = TEMPLATE): Promise<string> {
+  const page = await Bun.file(template).text()
+  const marker = '/*@@DATA@@*/null'
+  if (!page.includes(marker)) {
+    throw new Error(`${template} has no ${marker} to put the data in`)
+  }
+  const withData = page.replace(marker, () => inScript(data))
+  if (!data.maps) {
+    return withData
+  }
+  const script = await reviewScript()
+  return withData.replace('<!--@@REVIEW@@-->', () => `<script>${script}</script>`)
+}