@invisibleloop/pulse 0.5.1 → 0.6.1

package/src/runtime/ssr.js

@@ -146,7 +146,7 @@ export function renderToStream(spec, ctx = {}, nonce = '') {
         ? Object.fromEntries(await Promise.all([...fetcherCache.entries()].map(async ([k, p]) => [k, await p])))
         : {}
       const mergedAllState = mergeStoreKeys(spec, allServerState, ctx.store)
-      if (Object.keys(mergedAllState).length > 0) {
+      if (spec.hydrate && Object.keys(mergedAllState).length > 0) {
         controller.enqueue(encode(
           `<script nonce="${nonce}">window.__PULSE_SERVER__ = ${JSON.stringify(mergedAllState)};</script>`
         ))
@@ -314,8 +314,9 @@ export function wrapDocument({ content, spec = {}, serverState = {}, storeState
     : ''
 
   // Serialise server state into the page so the client runtime can read it
-  // without making a second request
-  const serverStateScript = Object.keys(serverState).length > 0
+  // without making a second request. Only needed when the page is hydrated —
+  // purely server-rendered pages have no JS to read it.
+  const serverStateScript = spec.hydrate && Object.keys(serverState).length > 0
     ? `<script nonce="${nonce}">window.__PULSE_SERVER__ = ${JSON.stringify(serverState)};</script>`
     : ''
 

package/src/runtime/ssr.test.js

@@ -61,7 +61,8 @@ const counterSpec = {
 }
 
 const serverDataSpec = {
-  route: '/products',
+  route:   '/products',
+  hydrate: '/src/pages/products.js',
   state: {},
   server: {
     products: async (ctx) => [
@@ -314,7 +315,8 @@ await test('stream.scope: shell does not wait for deferred-only fetchers', async
 
 await test('stream.scope: __PULSE_SERVER__ includes state from all scoped fetchers', async () => {
   const spec = {
-    route: '/scoped-state',
+    route:   '/scoped-state',
+    hydrate: '/src/pages/scoped-state.js',
     stream: {
       shell:    ['header'],
       deferred: ['feed'],
@@ -366,6 +368,7 @@ await test('sets og:title meta tag', async () => {
 await test('serialises server state into page', async () => {
   const { html } = wrapDocument({
     content:     '',
+    spec:        { hydrate: '/src/pages/products.js' },
     serverState: { products: [{ id: 1 }] }
   })
   assert(html.includes('__PULSE_SERVER__'), `Expected server state script: ${html}`)

package/src/spec/schema.js

@@ -324,7 +324,9 @@ export function validateSpec(spec) {
 
   // meta
   if (spec.meta) {
-    if (typeof spec.meta !== 'object') {
+    if (typeof spec.meta === 'function') {
+      errors.push('spec.meta must be a plain object, not a function. Individual fields (title, description, styles) can be async (ctx) => value functions, but meta itself must be {}')
+    } else if (typeof spec.meta !== 'object') {
       errors.push('spec.meta must be a plain object')
     } else if (spec.meta.schema !== undefined && typeof spec.meta.schema !== 'object') {
       errors.push('spec.meta.schema must be a plain object (JSON-LD)')

package/types/md.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Pulse — Markdown parser types
+ * @invisibleloop/pulse/md
+ */
+
+/** Parsed frontmatter key/value pairs from the --- block */
+export type Frontmatter = Record<string, string>
+
+/** Result of parsing a markdown string */
+export interface MdResult {
+  /** HTML string ready to pass to prose({ content }) */
+  html:         string
+  /** Key/value pairs parsed from the --- frontmatter block */
+  frontmatter:  Frontmatter
+}
+
+/** Request context passed to server fetchers */
+export interface MdContext {
+  params?: Record<string, string>
+  [key: string]: unknown
+}
+
+/** Async server fetcher returned by md() */
+export type MdFetcher = (ctx?: MdContext) => Promise<MdResult>
+
+/**
+ * Create a server fetcher that reads and parses a markdown file.
+ *
+ * Path patterns support :param placeholders resolved from ctx.params:
+ *   md('content/blog/:slug.md')
+ *
+ * The result is cached per request on ctx._mdCache so meta and server
+ * can both call the same fetcher without reading the file twice.
+ *
+ * Missing files throw an error with status 404 — add onViewError on
+ * dynamic routes to handle this gracefully.
+ *
+ * @example
+ * import { md }    from '@invisibleloop/pulse/md'
+ * import { prose } from '@invisibleloop/pulse/ui'
+ *
+ * const post = md('content/blog/:slug.md')
+ *
+ * export default {
+ *   route: '/blog/:slug',
+ *   meta: {
+ *     title:       async (ctx) => (await post(ctx)).frontmatter.title,
+ *     description: async (ctx) => (await post(ctx)).frontmatter.description,
+ *   },
+ *   server: { post },
+ *   view: (state, { post }) => prose({ content: post.html }),
+ *   onViewError: () => '<p>Post not found.</p>',
+ * }
+ */
+export function md(pathPattern: string | URL): MdFetcher
+
+/**
+ * Parse a markdown string into HTML and frontmatter.
+ * Use this when markdown comes from a database or API rather than a file.
+ *
+ * @example
+ * import { parseMd } from '@invisibleloop/pulse/md'
+ *
+ * const { html, frontmatter } = parseMd(record.body)
+ */
+export function parseMd(source: string): MdResult