@teleporthq/teleport-plugin-next-data-source 0.43.71 → 0.43.75

package/src/transformations/blog-adjacent-posts.ts

@@ -17,14 +17,25 @@ const ADJACENT_POST_CANDIDATES = 5
  *
  * MUST mirror `findAdjacentBlogPosts` in teleport-gui
  * `packages/renderer/src/utils/blog-adjacent-posts.ts` (the canvas).
+ *
+ * In Manual Order (`arranged`) a post walks the published posts of its
+ * PRIMARY category (the first of `category_ids`) the way the author arranged
+ * them: the ones with a place (`sort_order`) by it, then the rest newest
+ * first, ties by id — "previous" the one above it, "next" the one below. The
+ * category is read off each row in code, since a list cell may be JSON or a
+ * comma-separated list (see `array-overlap-sql.ts`). A post without a
+ * category, or a table the query cannot read (a column it lacks), walks the
+ * newest-first order above. MUST mirror `findArrangedAdjacentPosts` in
+ * teleport-gui `apps/gui/app/project-page/features/blog/utils/arranged-order.ts`.
  */
-export const generateAdjacentPostsCode = (): string => `
+export const generateAdjacentPostsCode = (postsTable: string, arranged = false): string => `
 var BLOG_ADJACENT_CANDIDATES = ${ADJACENT_POST_CANDIDATES}
+var BLOG_ARRANGED_ORDER = ${arranged}
 
 function blogAdjacentPostsSql(comparison, direction) {
   return (
-    'SELECT p.* FROM teleport_blog_posts p,' +
-    ' (SELECT created_at, id FROM teleport_blog_posts WHERE id = $1) cur' +
+    'SELECT p.* FROM ${postsTable} p,' +
+    ' (SELECT created_at, id FROM ${postsTable} WHERE id = $1) cur' +
     " WHERE p.status = 'published' AND (p.created_at, p.id) " + comparison + ' (cur.created_at, cur.id)' +
     ' ORDER BY p.created_at ' + direction + ', p.id ' + direction +
     ' LIMIT ' + BLOG_ADJACENT_CANDIDATES
@@ -44,6 +55,69 @@ function firstLinkableBlogPost(result) {
   return null
 }
 
+function blogPlaceOf(row) {
+  var raw = pickFirst(row.sort_order, row.sortOrder)
+  if (raw === null || raw === undefined || raw === '') return null
+  var value = Number(raw)
+  return isFinite(value) ? value : null
+}
+
+// The arranged posts by their place, then the rest newest first, ties by id descending.
+function compareBlogPlaces(a, b) {
+  var placeA = blogPlaceOf(a)
+  var placeB = blogPlaceOf(b)
+  if (placeA !== placeB) {
+    if (placeA === null) return 1
+    if (placeB === null) return -1
+    return placeA - placeB
+  }
+  var byDate =
+    normalizeTimestamp(pickFirst(b.created_at, b.createdAt)) -
+    normalizeTimestamp(pickFirst(a.created_at, a.createdAt))
+  if (byDate !== 0) return byDate
+  var idA = String(a.id)
+  var idB = String(b.id)
+  return idA < idB ? 1 : idA > idB ? -1 : 0
+}
+
+// { previous, next } along the post's primary category in Manual Order, or
+// null when the post has none (the caller then walks the newest-first order).
+async function getArrangedAdjacentPosts(client, record) {
+  var primary = parseJsonArray(record.category_ids)[0]
+  if (!primary) return null
+  var postId = String(record.id)
+  var listed = await client.query(
+    "SELECT id, category_ids, sort_order, created_at FROM ${postsTable} WHERE status = 'published' OR id = $1",
+    [postId]
+  )
+  var chain = (listed && Array.isArray(listed.rows) ? listed.rows : [])
+    .filter(function (row) {
+      return String(row.id) === postId || parseJsonArray(row.category_ids)[0] === primary
+    })
+    .sort(compareBlogPlaces)
+  var at = -1
+  for (var i = 0; i < chain.length; i++) {
+    if (String(chain[i].id) === postId) at = i
+  }
+  if (at < 0) return null
+  var above = chain.slice(Math.max(0, at - BLOG_ADJACENT_CANDIDATES), at).reverse()
+  var below = chain.slice(at + 1, at + 1 + BLOG_ADJACENT_CANDIDATES)
+  var ids = above.concat(below).map(function (row) { return String(row.id) })
+  if (ids.length === 0) return { previous: null, next: null }
+  var full = await client.query(
+    'SELECT p.* FROM ${postsTable} p WHERE p.id::text = ANY($1::text[])',
+    [ids]
+  )
+  var byId = {}
+  ;(full && Array.isArray(full.rows) ? full.rows : []).forEach(function (row) {
+    byId[String(row.id)] = row
+  })
+  var rowsOf = function (entries) {
+    return { rows: entries.map(function (row) { return byId[String(row.id)] }) }
+  }
+  return { previous: firstLinkableBlogPost(rowsOf(above)), next: firstLinkableBlogPost(rowsOf(below)) }
+}
+
 // { [postId]: { previous, next } } — raw rows or null — for a single-record
 // fetch; {} otherwise and on any failure (the navigation then hides).
 async function getAdjacentPostsMap(getClientFn, records) {
@@ -56,6 +130,18 @@ async function getAdjacentPostsMap(getClientFn, records) {
   try {
     client = getClientFn()
     await client.connect()
+    var arranged = null
+    if (BLOG_ARRANGED_ORDER) {
+      try {
+        arranged = await getArrangedAdjacentPosts(client, records[0])
+      } catch (e) {
+        // A table without the columns: the newest-first order below.
+      }
+    }
+    if (arranged) {
+      map[String(postId)] = arranged
+      return map
+    }
     var older = await client.query(blogAdjacentPostsSql('<', 'DESC'), [String(postId)])
     var newer = await client.query(blogAdjacentPostsSql('>', 'ASC'), [String(postId)])
     map[String(postId)] = {

package/src/transformations/blog-comments.ts

@@ -27,17 +27,17 @@ export const BLOG_COMMENTS_RENDER_LIMIT = 200
  * MUST mirror `buildBlogComments` in teleport-gui
  * `packages/renderer/src/utils/blog-comments.ts` (the canvas).
  */
-export const generateBlogCommentsCode = (): string => `
+export const generateBlogCommentsCode = (commentsTable: string): string => `
 var BLOG_COMMENTS_RENDER_LIMIT = ${BLOG_COMMENTS_RENDER_LIMIT}
 
 var BLOG_COMMENTS_SQL =
   'WITH top AS (' +
-  ' SELECT id FROM teleport_blog_comments' +
+  ' SELECT id FROM ${commentsTable}' +
   " WHERE post_id = $1 AND parent_id IS NULL AND status = 'approved'" +
   ' ORDER BY created_at DESC, id DESC LIMIT ' + BLOG_COMMENTS_RENDER_LIMIT +
   ')' +
   ' SELECT c.id, c.parent_id, c.author_name, c.content, c.is_author_reply, c.created_at' +
-  ' FROM teleport_blog_comments c' +
+  ' FROM ${commentsTable} c' +
   " WHERE c.post_id = $1 AND c.status = 'approved'" +
   ' AND (c.id IN (SELECT id FROM top) OR c.parent_id IN (SELECT id FROM top))' +
   ' ORDER BY c.created_at ASC, c.id ASC'
@@ -45,10 +45,10 @@ var BLOG_COMMENTS_SQL =
 // Every approved comment the page could show — a reply counts only while the
 // comment it answers is approved too.
 var BLOG_COMMENTS_COUNT_SQL =
-  'SELECT COUNT(*) AS n FROM teleport_blog_comments c' +
+  'SELECT COUNT(*) AS n FROM ${commentsTable} c' +
   " WHERE c.post_id = $1 AND c.status = 'approved'" +
   ' AND (c.parent_id IS NULL OR EXISTS (' +
-  ' SELECT 1 FROM teleport_blog_comments p' +
+  ' SELECT 1 FROM ${commentsTable} p' +
   " WHERE p.id = c.parent_id AND p.status = 'approved'))"
 
 function blogAuthorInitials(name) {

package/src/transformations/blog-post.ts

@@ -1,4 +1,5 @@
 import type { UIDLEcommerceCategory } from '@teleporthq/teleport-types'
+import { ContentTables, RichTextContentCodegen } from '@teleporthq/teleport-shared'
 import { generateCategoryTaxonomyCode } from './category-taxonomy'
 import { generateAdjacentPostsCode } from './blog-adjacent-posts'
 import { generateBlogCommentsCode } from './blog-comments'
@@ -6,10 +7,23 @@ import { generateHeadingAnchorsCode } from './heading-anchors'
 
 /** What the blog-post transform bakes in at export time beyond the row itself. */
 export interface BlogPostTransformOptions {
+  /**
+   * The preset's tables (the Blog's by default): the posts table the related
+   * and adjacent posts are read from, the comments table a post page counts.
+   */
+  tables?: ContentTables.ContentTables
   /** Category taxonomy — lives only in the UIDL, there is no DB table for it. */
   categories?: UIDLEcommerceCategory[]
   /** Content headings get ids and `#` links — see `heading-anchors.ts`. */
   headingAnchors?: boolean
+  /**
+   * The post pages carry a Contents list: the content's headings get their ids
+   * (the `#` links only with `headingAnchors`) and a post page's post its
+   * `sections` — see `blogContentsSectionsOf`.
+   */
+  contents?: boolean
+  /** Manual Order: Previous / Next walk the post's category as arranged — see `blog-adjacent-posts.ts`. */
+  arranged?: boolean
 }
 
 /**
@@ -20,15 +34,28 @@ export interface BlogPostTransformOptions {
 export const generateBlogPostTransformationCode = (
   options: BlogPostTransformOptions = {}
 ): string => {
+  const tables = options.tables ?? ContentTables.contentTablesByKey('blog')
   return `
 // ============================================================
 // Blog Post Transformation
 // ============================================================
 ${generateCategoryTaxonomyCode('BLOG_CATEGORIES_BY_ID', options.categories)}
-${generateBlogCommentsCode()}
-${generateAdjacentPostsCode()}
+${generateBlogCommentsCode(tables.comments ?? `${tables.posts}_comments`)}
+${generateAdjacentPostsCode(tables.posts, options.arranged === true)}
 ${generateHeadingAnchorsCode()}
+${RichTextContentCodegen.generateLegacyRichTextNormalizerCode()}
 var BLOG_HEADING_ANCHORS = ${options.headingAnchors === true}
+var BLOG_CONTENTS = ${options.contents === true}
+var BLOG_PICTURE_STAND_IN = ${tables.pictureStandIn !== false}
+
+// A post's reading time from its body, for one that stores none: its words at
+// about 200 a minute, at least one — what the editor's post form computes. A
+// card or post page otherwise printed "min read" with no number before it.
+// MUST mirror readingTimeOf in teleport-gui packages/renderer/src/utils/blog-posts.ts.
+function blogReadingTimeOf(html) {
+  var text = String(html || '').replace(/<[^>]*>/g, ' ').replace(/\\s+/g, ' ').trim()
+  return text ? Math.max(1, Math.ceil(text.split(' ').length / 200)) : null
+}
 
 function buildBlogPost(record, options) {
   if (!record || typeof record !== 'object') return record
@@ -42,8 +69,21 @@ function buildBlogPost(record, options) {
   // i18n-resolved text fields
   var title = resolveI18nField(record, 'title', 'title', currentLang, mainLang) || ''
   var slug = resolveI18nField(record, 'slug', 'slug', currentLang, mainLang) || ''
-  var content = resolveI18nField(record, 'content', 'content', currentLang, mainLang) || ''
-  if (BLOG_HEADING_ANCHORS) content = addHeadingAnchors(content)
+  // A body stored before the rich-text contract (the studio's flat list lines,
+  // the admin panel's no-break spaces) reads as stored HTML from here on.
+  var content = normalizeLegacyRichTextHtml(
+    resolveI18nField(record, 'content', 'content', currentLang, mainLang) || ''
+  )
+  // Counted before the heading anchors add their marks.
+  var bodyReadingTime = blogReadingTimeOf(content)
+  // The Contents list links to the headings, so they get their ids for it too
+  // — the # links only with the heading anchors on. Its sections ride on a
+  // post page's own fetch only (options.details): a listing draws no list, and
+  // every card of it would otherwise carry one.
+  var contentsHeadings = BLOG_CONTENTS && options.details === true ? [] : null
+  if (BLOG_HEADING_ANCHORS || BLOG_CONTENTS) {
+    content = addHeadingAnchors(content, { links: BLOG_HEADING_ANCHORS, sections: contentsHeadings })
+  }
   var excerpt = resolveI18nField(record, 'excerpt', 'excerpt', currentLang, mainLang) || ''
   var category = resolveI18nField(record, 'category', 'category', currentLang, mainLang) || null
 
@@ -77,11 +117,15 @@ function buildBlogPost(record, options) {
     rawFeaturedImage === TELEPORT_DEFAULT_FEATURED_IMG ||
     featuredImageUrl === TELEPORT_DEFAULT_FEATURED_IMG
   ) {
-    featuredImageUrl =
-      'data:image/svg+xml;charset=utf-8,' +
-      encodeURIComponent(
-        '<svg xmlns="http://www.w3.org/2000/svg" width="400" height="240" viewBox="0 0 400 240"><rect fill="#e5e7eb" width="400" height="240"/><text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" fill="#9ca3af" font-family="system-ui,sans-serif" font-size="13">No image</text></svg>'
-      )
+    // No picture of its own: the grey "No image" stand-in, or none at all for a
+    // preset whose posts are text (ContentTables.pictureStandIn) — its card and
+    // post page show the picture only when there is one.
+    featuredImageUrl = BLOG_PICTURE_STAND_IN
+      ? 'data:image/svg+xml;charset=utf-8,' +
+        encodeURIComponent(
+          '<svg xmlns="http://www.w3.org/2000/svg" width="400" height="240" viewBox="0 0 400 240"><rect fill="#e5e7eb" width="400" height="240"/><text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" fill="#9ca3af" font-family="system-ui,sans-serif" font-size="13">No image</text></svg>'
+        )
+      : null
   }
 
   var rawAuthorAvatar = pickFirst(record.author_avatar_url, record.authorAvatarUrl)
@@ -90,8 +134,11 @@ function buildBlogPost(record, options) {
   // Simple pass-through fields
   var authorName = pickFirst(record.author_name, record.authorName)
   var authorInitials = blogAuthorInitials(authorName)
-  var authorEmail = pickFirst(record.author_email, record.authorEmail)
+  // The author's email never leaves the server: a visitor's API read hides it
+  // (browser-row-policy.ts), and the page data a post or listing page ships
+  // is built here, so it is not part of the post a page sees either.
   var readingTimeMinutes = safeNumber(pickFirst(record.reading_time_minutes, record.readingTimeMinutes), null)
+  if (!(readingTimeMinutes > 0)) readingTimeMinutes = bodyReadingTime
 
   // Tags - i18n-resolved then parsed as JSON array
   var rawTags = resolveI18nField(record, 'tags', 'tags', currentLang, mainLang)
@@ -207,15 +254,16 @@ function buildBlogPost(record, options) {
     galleryImages: galleryImages,
     allImages: allImages,
     authorName: authorName,
-    authorEmail: authorEmail,
     author_name: authorName,
-    author_email: authorEmail,
     authorAvatarUrl: authorAvatarUrl,
     authorBio: authorBio,
     authorInitials: authorInitials,
     metaTitle: metaTitle,
     metaDescription: metaDescription,
     readingTimeMinutes: readingTimeMinutes,
+    // The post's sections, what its page's Contents list links to — see
+    // blogContentsSectionsOf; empty off a post page or under three sections.
+    sections: contentsHeadings ? blogContentsSectionsOf(contentsHeadings) : [],
     isFeatured: isFeatured,
     allowComments: allowComments,
     comments: comments,
@@ -231,6 +279,9 @@ function buildBlogPost(record, options) {
     createdAt: createdAt,
     updatedAt: updatedAt,
     created: created,
+    // The post's place among its primary category's posts (Manual Order), or
+    // null: what the category pages order by.
+    sortOrder: safeNumber(pickFirst(record.sort_order, record.sortOrder), null),
   }
 }
 
@@ -261,7 +312,7 @@ async function getRelatedPostsMap(getClientFn, records) {
   try {
     client = getClientFn()
     await client.connect()
-    var result = await client.query('SELECT * FROM teleport_blog_posts WHERE id = ANY($1)', [
+    var result = await client.query('SELECT * FROM ${tables.posts} WHERE id = ANY($1)', [
       wantedIds,
     ])
     if (result && result.rows) {

package/src/transformations/heading-anchors.ts

@@ -9,22 +9,51 @@
 export const BLOG_HEADING_ANCHOR_CLASS = 'tq-heading-anchor'
 
 /**
- * Generates `addHeadingAnchors(html)`: every `<h2>`–`<h6>` of a post's content
- * gets an `id` (kept when it already has one, otherwise a slug of its text,
- * unique within the post) and a trailing `#` link to itself, so a section can
- * be linked to (`/blog/post#setup`) and the link works on the very first load —
- * the ids are in the server-rendered HTML.
+ * The class of the link a post's content heading's own text becomes.
  *
- * The link repeats the heading a screen reader already announces, so it is
- * hidden from assistive technology and left out of the tab order; the heading
- * stays the landmark.
+ * ⛔ PAIRED with `BLOG_HEADING_LINK_CLASS` in teleport-gui
+ * `features/blog/utils/elements/heading-anchor-styles.ts`, whose stylesheet
+ * keeps the heading looking like a heading rather than like a link.
+ */
+export const BLOG_HEADING_LINK_CLASS = 'tq-heading-link'
+
+/**
+ * The fewest sections a post's Contents list is drawn for: a shorter post is
+ * taken in at a glance.
+ *
+ * ⛔ PAIRED with `CONTENTS_MIN_SECTIONS` in teleport-gui
+ * `packages/renderer/src/utils/blog-posts.ts`, the canvas's copy.
+ */
+export const CONTENTS_MIN_SECTIONS = 3
+
+/**
+ * Generates `addHeadingAnchors(html, options)`: every `<h2>`–`<h6>` of a post's
+ * content gets an `id` (kept when it already has one, otherwise a slug of its
+ * text, unique within the post), its text becomes a link to itself and a `#`
+ * follows it, shown on hover, so a section can be linked to
+ * (`/blog/post#setup`) by clicking its heading, and the link works on the very
+ * first load — the ids are in the server-rendered HTML. A heading that holds a
+ * link of its own keeps its text as it is (a link cannot hold another) and
+ * links through the `#` alone.
+ *
+ * `options.links: false` gives the headings their ids without the links —
+ * what a post page's Contents list needs when the heading anchors are off.
+ * `options.sections`, an array, collects every heading as `{ level, id, text }`
+ * in reading order, and `blogContentsSectionsOf` turns those into the list.
+ *
+ * The heading's text is the link a screen reader announces and the keyboard
+ * reaches; the `#` repeats it, so it is hidden from assistive technology and
+ * left out of the tab order.
  *
  * Idempotent: a heading that already carries the link is left alone. `h1` is
  * the post title's level and is never touched.
  */
 export const generateHeadingAnchorsCode = (): string => `
 var BLOG_HEADING_ANCHOR_CLASS = '${BLOG_HEADING_ANCHOR_CLASS}'
+var BLOG_HEADING_LINK_CLASS = '${BLOG_HEADING_LINK_CLASS}'
 var BLOG_HEADING_ID_PATTERN = /\\sid\\s*=\\s*("([^"]*)"|'([^']*)')/i
+var BLOG_HEADING_ANCHOR_LINK_PATTERN = /<a\\s[^>]*class="${BLOG_HEADING_ANCHOR_CLASS}"[^>]*>[\\s\\S]*?<\\/a>/gi
+var BLOG_CONTENTS_MIN_SECTIONS = ${CONTENTS_MIN_SECTIONS}
 
 function escapeHeadingAttribute(value) {
   return String(value)
@@ -52,11 +81,15 @@ function blogHeadingSlug(text, used) {
   return slug
 }
 
-function addHeadingAnchors(html) {
+function addHeadingAnchors(html, options) {
+  options = options || {}
+  var withLinks = options.links !== false
+  var sections = Array.isArray(options.sections) ? options.sections : null
   if (typeof html !== 'string' || !/<h[2-6][\\s>]/i.test(html)) return html
   // Every id the content already uses is taken, so a generated one never
-  // duplicates it.
-  var used = {}
+  // duplicates it. No prototype: a heading titled "Constructor" is free to be
+  // #constructor.
+  var used = Object.create(null)
   var existingIds = new RegExp(BLOG_HEADING_ID_PATTERN.source, 'gi')
   var existing
   while ((existing = existingIds.exec(html)) !== null) {
@@ -64,22 +97,52 @@ function addHeadingAnchors(html) {
   }
 
   return html.replace(/<h([2-6])(\\s[^>]*)?>([\\s\\S]*?)<\\/h\\1>/gi, function(match, level, rawAttrs, inner) {
-    if (inner.indexOf(BLOG_HEADING_ANCHOR_CLASS) !== -1) return match
-    var text = stripHtmlTags(inner)
-    if (!text) return match
     var attrs = rawAttrs || ''
     var idMatch = attrs.match(BLOG_HEADING_ID_PATTERN)
     var id = idMatch ? decodeHtmlEntities(idMatch[2] || idMatch[3] || '') : ''
+    if (inner.indexOf(BLOG_HEADING_ANCHOR_CLASS) !== -1) {
+      if (sections && id) {
+        var anchoredText = stripHtmlTags(inner.replace(BLOG_HEADING_ANCHOR_LINK_PATTERN, ''))
+        if (anchoredText) sections.push({ level: Number(level), id: id, text: anchoredText })
+      }
+      return match
+    }
+    var text = stripHtmlTags(inner)
+    if (!text) return match
     if (!id) {
       id = blogHeadingSlug(text, used)
       attrs = ' id="' + escapeHeadingAttribute(id) + '"' + attrs
     }
+    if (sections) sections.push({ level: Number(level), id: id, text: text })
+    if (!withLinks) return '<h' + level + attrs + '>' + inner + '</h' + level + '>'
+    var href = '#' + escapeHeadingAttribute(id)
+    var ownText = /<a[\\s>]/i.test(inner)
+      ? inner
+      : '<a class="' + BLOG_HEADING_LINK_CLASS + '" href="' + href + '">' + inner + '</a>'
     return (
-      '<h' + level + attrs + '>' + inner +
-      '<a class="' + BLOG_HEADING_ANCHOR_CLASS + '" href="#' + escapeHeadingAttribute(id) +
+      '<h' + level + attrs + '>' + ownText +
+      '<a class="' + BLOG_HEADING_ANCHOR_CLASS + '" href="' + href +
       '" aria-hidden="true" tabindex="-1">#</a>' +
       '</h' + level + '>'
     )
   })
 }
+
+// A post page's Contents list: the post's sections, i.e. its headings of the
+// topmost level it uses, each with the address that jumps to it; none for a
+// post of fewer than BLOG_CONTENTS_MIN_SECTIONS sections.
+// MUST mirror contentsSectionsOf in teleport-gui packages/renderer/src/utils/blog-posts.ts.
+function blogContentsSectionsOf(headings) {
+  if (!Array.isArray(headings) || headings.length === 0) return []
+  var top = 6
+  for (var i = 0; i < headings.length; i++) {
+    if (headings[i].level < top) top = headings[i].level
+  }
+  var sections = []
+  for (var j = 0; j < headings.length; j++) {
+    if (headings[j].level !== top) continue
+    sections.push({ id: headings[j].id, title: headings[j].text, href: '#' + headings[j].id })
+  }
+  return sections.length >= BLOG_CONTENTS_MIN_SECTIONS ? sections : []
+}
 `

package/src/transformations/index.ts

@@ -1,9 +1,10 @@
 import type {
   GeneratorOptions,
+  UIDLBlogSettings,
   UIDLAuthentication,
   UIDLEcommerceCategory,
 } from '@teleporthq/teleport-types'
-import { StorefrontTax, TableAccess } from '@teleporthq/teleport-shared'
+import { ContentTables, StorefrontTax, TableAccess } from '@teleporthq/teleport-shared'
 import { generateSharedTransformationCode } from './shared-utils'
 import { generateBlogPostTransformationCode } from './blog-post'
 import { generateCustomPageTransformationCode } from './custom-page'
@@ -26,7 +27,22 @@ export type { EcommerceProductTransformOptions }
  * to serve whichever transform that resolves to — the product fields are ignored
  * for a blog table and vice versa.
  */
+/** What a content preset bakes into its post transform — see `UIDLBlogSettings`. */
+export interface ContentPresetTransformSettings {
+  categories?: UIDLEcommerceCategory[]
+  headingAnchors?: boolean
+  contents?: boolean
+  comments?: boolean
+  order?: 'manual'
+}
+
 export interface EntityTransformOptions extends EcommerceProductTransformOptions {
+  /**
+   * The settings of every content preset, by preset key — the post transform
+   * of a table reads its own preset's (`contentSettingsFor`). The `blog*`
+   * fields below are the Blog's, kept for the callers that name them.
+   */
+  contentSettings?: Partial<Record<ContentTables.ContentPresetKey, ContentPresetTransformSettings>>
   /** Blog post-category taxonomy — see `blogSettings.categories`. */
   blogCategories?: UIDLEcommerceCategory[]
   /** Post content headings get ids and `#` links — see `blogSettings.headingAnchors`. */
@@ -77,10 +93,50 @@ const resolveAllowBackorders = (
  * tax-inclusive or untaxed stores. `allowBackorders` is the effective
  * "stock never blocks a purchase" flag — see `resolveAllowBackorders`.
  */
+const contentPresetTransformSettings = (
+  settings: UIDLBlogSettings | undefined
+): ContentPresetTransformSettings => ({
+  categories: settings?.categories,
+  headingAnchors: settings?.headingAnchors === true,
+  ...(settings?.contents === true && { contents: true }),
+  comments: settings?.comments === true,
+  ...(settings?.order === 'manual' && { order: 'manual' as const }),
+})
+
+/**
+ * The settings the transform of `tableName` bakes in: its preset's entry in
+ * `contentSettings`, or — for the Blog, and for a caller that only set the
+ * `blog*` fields — those fields. Empty for a table no preset owns.
+ */
+export const contentSettingsFor = (
+  options: Pick<
+    EntityTransformOptions,
+    'contentSettings' | 'blogCategories' | 'blogHeadingAnchors' | 'blogComments'
+  >,
+  tableName: string
+): ContentPresetTransformSettings => {
+  const role = ContentTables.contentTableRole(stripSchemaQualifier(tableName))
+  if (!role) {
+    return {}
+  }
+  const own = options.contentSettings?.[role.key]
+  if (own) {
+    return own
+  }
+  if (role.key === 'blog') {
+    return {
+      categories: options.blogCategories,
+      headingAnchors: options.blogHeadingAnchors,
+      comments: options.blogComments,
+    }
+  }
+  return {}
+}
+
 export const buildProductTransformOptions = (
   options: Pick<
     GeneratorOptions,
-    'ecommerceSettings' | 'invoiceSettings' | 'blogSettings' | 'auth'
+    'ecommerceSettings' | 'invoiceSettings' | 'blogSettings' | 'helpCenterSettings' | 'auth'
   > &
     LocalizedProjectOptions & {
       /**
@@ -96,6 +152,10 @@ export const buildProductTransformOptions = (
     }
 ): EntityTransformOptions => ({
   categories: options.ecommerceSettings?.categories,
+  contentSettings: {
+    blog: contentPresetTransformSettings(options.blogSettings),
+    help: contentPresetTransformSettings(options.helpCenterSettings),
+  },
   blogCategories: options.blogSettings?.categories,
   blogHeadingAnchors: options.blogSettings?.headingAnchors === true,
   blogComments: options.blogSettings?.comments === true,
@@ -125,9 +185,9 @@ const stripSchemaQualifier = (tableName: string): string => {
  * Detects which transformation type to apply based on the table name.
  * Returns null if no transformation is needed.
  *
- * IMPORTANT: Only the real platform-managed tables (`teleport_products`,
- * `teleport_blog_posts`) are routed through the e-commerce/blog view-model
- * transforms. A previous loose substring match (`lower.includes('products')`)
+ * IMPORTANT: Only the real platform-managed tables (`teleport_products`, the
+ * content presets' posts tables) are routed through the e-commerce/blog
+ * view-model transforms. A previous loose substring match (`lower.includes('products')`)
  * incorrectly routed CUSTOM tables such as `products`, `store_products` or
  * `wholesale_products` through `buildEcommerceProduct`, which emits a fixed set
  * of platform product fields and silently drops all custom columns. Matching the
@@ -138,7 +198,7 @@ export const detectTransformationType = (tableName: string): TransformationType
     return null
   }
   const bare = stripSchemaQualifier(tableName)
-  if (bare === 'teleport_blog_posts') {
+  if (ContentTables.isContentPostsTable(bare)) {
     return 'blog-post'
   }
   if (bare === 'teleport_products') {
@@ -167,14 +227,20 @@ export const getTransformationCode = (
   const shared = generateSharedTransformationCode()
 
   switch (type) {
-    case 'blog-post':
+    case 'blog-post': {
+      const role = ContentTables.contentTableRole(stripSchemaQualifier(tableName))
+      const settings = contentSettingsFor(options, tableName)
       return (
         shared +
         generateBlogPostTransformationCode({
-          categories: options.blogCategories,
-          headingAnchors: options.blogHeadingAnchors,
+          tables: role ? ContentTables.contentTablesByKey(role.key) : undefined,
+          categories: settings.categories,
+          headingAnchors: settings.headingAnchors,
+          contents: settings.contents === true,
+          arranged: settings.order === 'manual',
         })
       )
+    }
     case 'ecommerce-product':
       return shared + generateEcommerceProductTransformationCode(options)
     case 'custom-page':
@@ -300,7 +366,7 @@ export const REVIEWS_PER_PRODUCT = 5
  */
 export const getTransformWrapperCode = (
   tableName: string,
-  options: Pick<EntityTransformOptions, 'localization' | 'blogComments'> = {}
+  options: Pick<EntityTransformOptions, 'localization' | 'blogComments' | 'contentSettings'> = {}
 ): string => {
   const type = detectTransformationType(tableName)
   if (!type) {
@@ -422,7 +488,8 @@ export const getTransformWrapperCode = (
 
   // A post page's neighbours and comments, on the same single-record heuristic
   // as the related rail. The comments are only asked for when the blog takes
-  // them — see `EntityTransformOptions.blogComments`.
+  // them — see `EntityTransformOptions.blogComments`. `details` tells the
+  // transform the same thing: what only a post page draws (its Contents list).
   const blogPageEnrichment =
     type === 'blog-post'
       ? `
@@ -434,7 +501,7 @@ export const getTransformWrapperCode = (
     } catch (e) {
       // Best-effort; the post navigation stays hidden.
     }${
-      options.blogComments
+      contentSettingsFor(options, tableName).comments === true
         ? `
     try {
       commentsByPostId = await getBlogCommentsMap(getClientFn, records)
@@ -447,7 +514,7 @@ export const getTransformWrapperCode = (
       : ''
   const blogPageOption =
     type === 'blog-post'
-      ? ', adjacentPostsById: adjacentPostsById, commentsByPostId: commentsByPostId'
+      ? ', adjacentPostsById: adjacentPostsById, commentsByPostId: commentsByPostId, details: Array.isArray(records) && records.length === 1'
       : ''
 
   return `${RAW_ROWS_CODE}