@gjsify/site 0.64.10 → 0.64.12-next.279

package/lib/render/markdown.js

@@ -20,24 +20,84 @@ function isTableStart(lines, index) {
 }
 function isBlockStart(lines, index) {
     const line = lines[index];
-    return (line.trim() === '' ||
-        HEADING.test(line) ||
-        HR.test(line.trim()) ||
-        ORDERED.test(line) ||
-        UNORDERED.test(line) ||
-        isTableStart(lines, index));
+    const trimmed = line.trim();
+    if (trimmed === '') {
+        return true;
+    }
+    if (HEADING.test(line)) {
+        return true;
+    }
+    if (HR.test(trimmed)) {
+        return true;
+    }
+    if (ORDERED.test(line) || UNORDERED.test(line)) {
+        return true;
+    }
+    if (isTableStart(lines, index)) {
+        return true;
+    }
+    if (trimmed.startsWith('```') || trimmed.startsWith('~~~')) {
+        return true;
+    }
+    if (trimmed.startsWith('>')) {
+        return true;
+    }
+    // Image paragraph check - handled separately, but treat as block start
+    if (/^!\[([^\]]*)\]\([^)]+\)$/.test(trimmed) ||
+        /^!\[([^\]]*)\]\([^)]+\s+"[^"]*"\)$/.test(trimmed) ||
+        /^!\[([^\]]*)\]\([^)]+\s+'[^']*'\)$/.test(trimmed)) {
+        return true;
+    }
+    return false;
 }
-function parseBlocks(source) {
+function parseBlocks(source, options = {}) {
     const lines = source.replace(/\r\n/g, '\n').split('\n');
     const blocks = [];
     let i = 0;
+    const resolveUrl = options.resolveUrl;
     while (i < lines.length) {
         const line = lines[i];
         if (line.trim() === '') {
             i++;
             continue;
         }
-        if (HR.test(line.trim())) {
+        const trimmed = line.trim();
+        // Fenced code blocks
+        const fenceMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+        if (fenceMatch) {
+            const fence = fenceMatch[1];
+            const fenceChar = fence[0];
+            const infoString = (fenceMatch[2] || '').trim();
+            i++;
+            const codeLines = [];
+            while (i < lines.length) {
+                const currentLine = lines[i];
+                const currentTrimmed = currentLine.trim();
+                // Check if it's the closing fence
+                if (fenceChar === '`') {
+                    if (/^`{3,}\s*$/.test(currentTrimmed) && currentTrimmed.length >= fence.length) {
+                        i++;
+                        break;
+                    }
+                }
+                else if (fenceChar === '~') {
+                    if (/^~{3,}\s*$/.test(currentTrimmed) && currentTrimmed.length >= fence.length) {
+                        i++;
+                        break;
+                    }
+                }
+                codeLines.push(currentLine);
+                i++;
+            }
+            // Remove trailing newline inside code? "no trailing newline inside code"
+            let content = codeLines.join('\n');
+            if (content.endsWith('\n')) {
+                content = content.slice(0, -1);
+            }
+            blocks.push({ kind: 'code', lang: infoString || undefined, content });
+            continue;
+        }
+        if (HR.test(trimmed)) {
             blocks.push({ kind: 'hr' });
             i++;
             continue;
@@ -64,12 +124,50 @@ function parseBlocks(source) {
             const pattern = ordered ? ORDERED : UNORDERED;
             const items = [];
             while (i < lines.length && pattern.test(lines[i])) {
-                items.push(pattern.exec(lines[i])[1].trim());
+                let item = pattern.exec(lines[i])[1].trim();
                 i++;
+                // An indented line under an item is that item, wrapped.
+                while (i < lines.length && /^\s+\S/.test(lines[i]) && !pattern.test(lines[i])) {
+                    item += ` ${lines[i].trim()}`;
+                    i++;
+                }
+                items.push(item);
             }
             blocks.push({ kind: 'list', ordered, items });
             continue;
         }
+        // Blockquote
+        if (trimmed.startsWith('>')) {
+            const quoteLines = [];
+            while (i < lines.length) {
+                const qline = lines[i];
+                const qtrimmed = qline.trim();
+                if (qtrimmed.startsWith('>')) {
+                    // Remove > and optional space
+                    const content = qline.replace(/^\s*>\s?/, '');
+                    quoteLines.push(content);
+                    i++;
+                    continue;
+                }
+                break;
+            }
+            blocks.push({ kind: 'blockquote', content: quoteLines.join('\n') });
+            continue;
+        }
+        // Image
+        const imgMatch = trimmed.match(/^!\[([^\]]*)\]\(([^)]+?)(?:\s+"([^"]*)")?\)$/) ||
+            trimmed.match(/^!\[([^\]]*)\]\(([^)]+?)(?:\s+'([^']*)')?\)$/);
+        if (imgMatch) {
+            let src = imgMatch[2].trim();
+            if (resolveUrl) {
+                src = resolveUrl(src);
+            }
+            const alt = imgMatch[1] || '';
+            const title = imgMatch[3];
+            blocks.push({ kind: 'image', src, alt, title, isFigure: true });
+            i++;
+            continue;
+        }
         const paragraph = [];
         while (i < lines.length && !isBlockStart(lines, i)) {
             paragraph.push(lines[i].trim());
@@ -80,34 +178,161 @@ function parseBlocks(source) {
     return blocks;
 }
 /** Escapes first, then marks up the already-escaped text — a link's URL and label are both safe. */
-function renderInline(text) {
+function renderInline(text, options = {}) {
+    const resolveUrl = options.resolveUrl;
     let html = esc(text);
-    html = html.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_match, label, url) => `<a href="${url}">${label}</a>`);
+    // Images
+    html = html.replace(/!\[([^\]]*)\]\(([^)\s]+?)(?:\s+"([^"]*)")?\)/g, (_match, alt, src, title) => {
+        // Groups are from escaped text
+        let resolvedSrc = src
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (resolveUrl) {
+            resolvedSrc = resolveUrl(resolvedSrc);
+        }
+        let altUnesc = alt
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        const titleAttr = title ? ` title="${esc(title.replace(/&quot;/g, '"'))}"` : '';
+        return `<img src="${esc(resolvedSrc)}" alt="${esc(altUnesc)}" loading="lazy"${titleAttr}>`;
+    });
+    html = html.replace(/!\[([^\]]*)\]\(([^)\s]+?)(?:\s+'([^']*)')?\)/g, (_match, alt, src, title) => {
+        let resolvedSrc = src
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (resolveUrl) {
+            resolvedSrc = resolveUrl(resolvedSrc);
+        }
+        let altUnesc = alt
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        const titleAttr = title ? ` title="${esc(title.replace(/&#39;/g, "'"))}"` : '';
+        return `<img src="${esc(resolvedSrc)}" alt="${esc(altUnesc)}" loading="lazy"${titleAttr}>`;
+    });
+    html = html.replace(/\[([^\]]+)\]\(([^)\s]+?)(?:\s+"([^"]*)")?\)/g, (_match, label, url) => {
+        let resolvedUrl = url
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (resolveUrl) {
+            resolvedUrl = resolveUrl(resolvedUrl);
+        }
+        return `<a href="${esc(resolvedUrl)}">${label}</a>`;
+    });
+    html = html.replace(/\[([^\]]+)\]\(([^)\s]+?)(?:\s+'([^']*)')?\)/g, (_match, label, url) => {
+        let resolvedUrl = url
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (resolveUrl) {
+            resolvedUrl = resolveUrl(resolvedUrl);
+        }
+        return `<a href="${esc(resolvedUrl)}">${label}</a>`;
+    });
+    // Also handle links without title
+    html = html.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_match, label, url) => {
+        let resolvedUrl = url
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'");
+        if (resolveUrl) {
+            resolvedUrl = resolveUrl(resolvedUrl);
+        }
+        return `<a href="${esc(resolvedUrl)}">${label}</a>`;
+    });
     html = html.replace(/`([^`]+)`/g, (_match, code) => `<code>${code}</code>`);
-    html = html.replace(/\*\*([^*]+)\*\*/g, (_match, bold) => `<strong>${bold}</strong>`);
+    // Bold first (** takes precedence) - be careful not to break
+    html = html.replace(/\*\*([^*]+?)\*\*/g, (_match, bold) => `<strong>${bold}</strong>`);
+    // Emphasis with * - single asterisks not part of **
+    html = html.replace(/(?<!\*)\*([^*\s][^*]*?|[^*\s])\*(?!\*)/g, (_match, content) => {
+        return `<em>${content}</em>`;
+    });
+    // Emphasis with _ - must not break snake_case (no word chars immediately adjacent on both sides)
+    // Use word boundary checks
+    html = html.replace(/(^|[^a-zA-Z0-9])_([^_\s][^_]*?|[^_\s])_([^a-zA-Z0-9]|$)/g, (_match, p1, content, p3) => {
+        return p1 + `<em>${content}</em>` + p3;
+    });
     return html;
 }
-function renderBlock(block) {
+function renderBlock(block, options = {}) {
     switch (block.kind) {
         case 'heading':
-            return `<h${block.level}>${renderInline(block.text)}</h${block.level}>`;
+            return `<h${block.level}>${renderInline(block.text, options)}</h${block.level}>`;
         case 'paragraph':
-            return `<p>${renderInline(block.text)}</p>`;
+            // Check if paragraph contains only an image
+            const imgOnlyMatch = block.text.match(/^!\[([^\]]*)\]\(([^)]+?)(?:\s+"([^"]*)")?\)$/) ||
+                block.text.match(/^!\[([^\]]*)\]\(([^)]+?)(?:\s+'([^']*)')?\)$/);
+            if (imgOnlyMatch) {
+                let src = imgOnlyMatch[2].trim();
+                if (options.resolveUrl) {
+                    src = options.resolveUrl(src);
+                }
+                const alt = imgOnlyMatch[1] || '';
+                const title = imgOnlyMatch[3];
+                const titleAttr = title ? ` title="${esc(title)}"` : '';
+                if (title) {
+                    return `<figure><img src="${esc(src)}" alt="${esc(alt)}" loading="lazy"${titleAttr}><figcaption>${esc(title)}</figcaption></figure>`;
+                }
+                return `<figure><img src="${esc(src)}" alt="${esc(alt)}" loading="lazy"${titleAttr}></figure>`;
+            }
+            return `<p>${renderInline(block.text, options)}</p>`;
         case 'list': {
             const tag = block.ordered ? 'ol' : 'ul';
-            return `<${tag}>${block.items.map((item) => `<li>${renderInline(item)}</li>`).join('')}</${tag}>`;
+            return `<${tag}>${block.items.map((item) => `<li>${renderInline(item, options)}</li>`).join('')}</${tag}>`;
         }
         case 'table': {
-            const head = `<thead><tr>${block.header.map((cell) => `<th>${renderInline(cell)}</th>`).join('')}</tr></thead>`;
+            const head = `<thead><tr>${block.header.map((cell) => `<th>${renderInline(cell, options)}</th>`).join('')}</tr></thead>`;
             const body = `<tbody>${block.rows
-                .map((row) => `<tr>${row.map((cell) => `<td>${renderInline(cell)}</td>`).join('')}</tr>`)
+                .map((row) => `<tr>${row.map((cell) => `<td>${renderInline(cell, options)}</td>`).join('')}</tr>`)
                 .join('')}</tbody>`;
             return `<table>${head}${body}</table>`;
         }
         case 'hr':
             return '<hr>';
+        case 'code': {
+            if (block.lang) {
+                return `<pre><code class="language-${esc(block.lang)}">${esc(block.content)}</code></pre>`;
+            }
+            return `<pre><code>${esc(block.content)}</code></pre>`;
+        }
+        case 'blockquote': {
+            const inner = parseBlocks(block.content, options)
+                .map((b) => renderBlock(b, options))
+                .join('\n');
+            return `<blockquote>${inner}</blockquote>`;
+        }
+        case 'image': {
+            const titleAttr = block.title ? ` title="${esc(block.title)}"` : '';
+            if (block.title && block.isFigure) {
+                return `<figure><img src="${esc(block.src)}" alt="${esc(block.alt)}" loading="lazy"${titleAttr}><figcaption>${esc(block.title)}</figcaption></figure>`;
+            }
+            if (block.isFigure) {
+                return `<figure><img src="${esc(block.src)}" alt="${esc(block.alt)}" loading="lazy"${titleAttr}></figure>`;
+            }
+            return `<img src="${esc(block.src)}" alt="${esc(block.alt)}" loading="lazy"${titleAttr}>`;
+        }
     }
 }
-export function renderMarkdown(source) {
-    return parseBlocks(source).map(renderBlock).join('\n');
+export function renderMarkdown(source, options = {}) {
+    return parseBlocks(source, options)
+        .map((b) => renderBlock(b, options))
+        .join('\n');
 }

package/lib/render/pages.d.ts

@@ -1,10 +1,7 @@
-import { type DownloadTarget, type Localized, type Screenshot, type SiteData, type SiteSupportSepa } from '../site-data/index.js';
+import { type DownloadTarget, type Localized, type RelatedApp, type Screenshot, type SiteData, type SiteSupportEntry, type SiteSupportSepa } from '../site-data/index.js';
 import { type IconName } from './icons.js';
+import { type ClientAssets, type Shell, type Translate } from './layout.js';
 import type { ProcessedImage } from './images.js';
-export interface ClientAssets {
-    js: string;
-    css: string[];
-}
 export interface RenderContext {
     data: SiteData;
     lang: string;
@@ -18,8 +15,11 @@ export interface RenderContext {
     view?: 'app' | 'support' | 'privacy' | 'legal-notice';
     /** Root-relative URL of the link-preview card for this language. */
     ogImage?: string;
+    /** The blog's latest posts in this language, rendered; only the landing page shows them. */
+    latestPosts?: string;
+    /** Root-relative URL of the published `theme.displayFont`. */
+    displayFontUrl?: string;
 }
-type Translate = (msgid: string) => string;
 /** What the download dialog reads: the targets, the catalogue and the locale it formats sizes in. */
 export type DownloadContext = Pick<RenderContext, 'data' | 't' | 'lang'>;
 export declare function localized(text: Localized, lang: string): string;
@@ -35,7 +35,6 @@ export declare function privacyUrl(data: SiteData, lang: string): string;
 export declare function legalNoticeUrl(data: SiteData, lang: string): string;
 /** The transfer reference when the config sets none: one per app, so the bank statement says what it was for. */
 export declare function supportReference(data: SiteData): string;
-export declare function languageName(code: string): string;
 /**
  * What the primary button says. Installing from a store, opening the web build and downloading a
  * file are three different promises, so each gets its own wording.
@@ -58,6 +57,8 @@ export declare function downloadWidget(ctx: DownloadContext): string;
  */
 export declare function badges(ctx: Pick<RenderContext, 'data' | 't' | 'lang'>): string;
 export declare function linkCard(href: string, title: string, glyph: IconName): string;
+/** One app as a card: icon, name, summary. Also the app grid of a developer site. */
+export declare function relatedCard(app: RelatedApp, lang: string): string;
 /** Other apps of the same developer, resolved at build time so the page needs no script. */
 export declare function relatedSection(ctx: Pick<RenderContext, 'data' | 'lang' | 't'>): string;
 /** A bank transfer as a card: the details to read or copy, and an EPC QR code that fills them into a banking app. */
@@ -68,9 +69,22 @@ export declare function pageMeta(ctx: Pick<RenderContext, 'data' | 'lang' | 't'>
     title: string;
     description: string;
 };
+/** The frame of every page of an app site in one language. */
+export declare function appShell(ctx: Pick<RenderContext, 'data' | 'lang' | 't' | 'assets' | 'iconUrl' | 'displayFontUrl'> & {
+    current?: 'blog';
+}): Shell;
 export declare function renderPage(ctx: RenderContext): string;
+/** The support entries as cards; shared with the developer site, whose reference is the person's. */
+export declare function supportList(entries: readonly SiteSupportEntry[], t: Translate, reference: string): string;
 /** `/<lang>/support/`: the ways to support the app, as plain markup that needs no script. */
 export declare function renderSupportPage(page: RenderContext): string;
+/**
+ * The paragraph every privacy page opens with, regardless of what the site is about. It is about
+ * visiting THIS static page — this package adds no cookie, no analytics and no third-party resource
+ * of its own, so that much is true for every consumer. `hostingPolicyUrl` is the one fact that
+ * varies by deployment and is not guessed; left out, nothing about hosting is said.
+ */
+export declare function hostingNotice(config: Pick<SiteData['config'], 'privacy'>, t: Translate): string;
 /**
  * `/<lang>/privacy/`: the hosting paragraph above, then the app's own statement of what it does
  * with data — read verbatim from the file `gjsify.site.privacy.statements[lang]` names, rendered
@@ -87,4 +101,3 @@ export declare function renderPrivacyPage(page: RenderContext, statement: string
 export declare function renderLegalNoticePage(page: RenderContext, statement: string): string;
 /** The root page: a script picks the visitor's language, the link list is what everyone else (and every crawler) sees. */
 export declare function renderRoot(data: SiteData, assets: ClientAssets, iconUrl: string | undefined): string;
-export {};