ferst-core 0.6.2 → 0.7.2

package/lib/inline-markdown.ts

@@ -1,52 +1,65 @@
-/**
- * inlineMarkdown — render a *tiny*, safe subset of markdown from trusted editor/CMS
- * text: links `[label](href)`, bold `**text**`, and single newlines → `<br>`.
- * Everything is HTML-escaped first, and only safe href schemes (http(s), root-
- * relative, mailto, tel, in-page #anchors) become links — an unsafe href renders
- * as literal text. The result is safe to drop into `set:html` for trusted content.
- *
- * This exists so recipes that show a line or two of editor copy (FAQ answers,
- * notices) can carry a link without a full markdown pipeline — and without the
- * `[text](url)` showing through as literal characters.
- */
-const ESCAPE: Record<string, string> = {
-  '&': '&amp;',
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  "'": '&#39;',
-};
-function escapeHtml(s: string): string {
-  return s.replace(/[&<>"']/g, (c) => ESCAPE[c]);
-}
-
-/** Only these href schemes are allowed to become real links. */
-const SAFE_HREF = /^(?:https?:\/\/|\/|mailto:|tel:|#)/i;
-
-const LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
-
-/** Bold + single-newline breaks, applied to already-escaped text. */
-function inlineFormat(escaped: string): string {
-  return escaped.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>').replace(/\n/g, '<br>');
-}
-
-export function inlineMarkdown(text: string | undefined | null): string {
-  if (!text) return '';
-  let out = '';
-  let last = 0;
-  let m: RegExpExecArray | null;
-  LINK_RE.lastIndex = 0;
-  while ((m = LINK_RE.exec(text))) {
-    out += inlineFormat(escapeHtml(text.slice(last, m.index)));
-    const label = inlineFormat(escapeHtml(m[1]));
-    const href = m[2];
-    if (SAFE_HREF.test(href)) {
-      out += `<a href="${escapeHtml(href)}">${label}</a>`;
-    } else {
-      out += inlineFormat(escapeHtml(m[0])); // unsafe scheme → keep literal
-    }
-    last = m.index + m[0].length;
-  }
-  out += inlineFormat(escapeHtml(text.slice(last)));
-  return out;
-}
+/**
+ * inlineMarkdown — render a *tiny*, safe subset of markdown from trusted editor/CMS
+ * text: links `[label](href)`, bold `**text**`, italic `*text*` / `_text_`, and single
+ * newlines → `<br>`.
+ * Everything is HTML-escaped first, and only safe href schemes (http(s), root-
+ * relative, mailto, tel, in-page #anchors) become links — an unsafe href renders
+ * as literal text. The result is safe to drop into `set:html` for trusted content.
+ *
+ * This exists so recipes that show a line or two of editor copy (FAQ answers,
+ * notices) can carry a link without a full markdown pipeline — and without the
+ * `[text](url)` showing through as literal characters.
+ */
+const ESCAPE: Record<string, string> = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+};
+function escapeHtml(s: string): string {
+  return s.replace(/[&<>"']/g, (c) => ESCAPE[c]);
+}
+
+/** Only these href schemes are allowed to become real links. */
+const SAFE_HREF = /^(?:https?:\/\/|\/|mailto:|tel:|#)/i;
+
+const LINK_RE = /\[([^\]]+)\]\(([^)\s]+)\)/g;
+
+/** Bold, italic + single-newline breaks, applied to already-escaped text. Italic
+ *  `*x*` / `_x_` must hug its text, and `_` only counts at word edges, so
+ *  snake_case and a lone asterisk stay literal. */
+function inlineFormat(escaped: string): string {
+  return escaped
+    .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+    .replace(/(^|[^*\w])\*(?![\s*])([^*]*?[^\s*])\*(?!\*)/g, '$1<em>$2</em>')
+    .replace(/(^|[^\w])_(?![\s_])([^_]*?[^\s_])_(?!\w)/g, '$1<em>$2</em>')
+    .replace(/\n/g, '<br>');
+}
+
+/** Escaped text with single newlines → `<br>`, and no links: for text that already sits
+ *  inside a link (a nested <a> is invalid). */
+export function textWithBreaks(text: string | undefined | null): string {
+  return text ? escapeHtml(text).replace(/\n/g, '<br>') : '';
+}
+
+export function inlineMarkdown(text: string | undefined | null): string {
+  if (!text) return '';
+  let out = '';
+  let last = 0;
+  let m: RegExpExecArray | null;
+  LINK_RE.lastIndex = 0;
+  while ((m = LINK_RE.exec(text))) {
+    out += inlineFormat(escapeHtml(text.slice(last, m.index)));
+    const label = inlineFormat(escapeHtml(m[1]));
+    const href = m[2];
+    if (SAFE_HREF.test(href)) {
+      out += `<a href="${escapeHtml(href)}">${label}</a>`;
+    } else {
+      out += inlineFormat(escapeHtml(m[0])); // unsafe scheme → keep literal
+    }
+    last = m.index + m[0].length;
+  }
+  out += inlineFormat(escapeHtml(text.slice(last)));
+  return out;
+}

package/lib/prose.ts

@@ -0,0 +1,29 @@
+/**
+ * Prose → paragraphs and simple lists, for the `prose` block. Blank lines separate
+ * paragraphs; a paragraph whose every line starts `- ` / `* ` becomes a bulleted list,
+ * and one whose every line starts `1. ` / `1) ` a numbered list. Inline formatting
+ * (links incl. tel:/mailto:, bold, italic) comes from inlineMarkdown, which escapes
+ * everything first — so the output is safe for `set:html`.
+ */
+import { inlineMarkdown } from './inline-markdown';
+
+export type ProsePart =
+  | { kind: 'p'; html: string }
+  | { kind: 'ul' | 'ol'; items: string[] };
+
+const BULLET = /^\s*[-*•]\s+/;
+const NUMBER = /^\s*\d+[.)]\s+/;
+
+export function proseParts(text: string | undefined | null): ProsePart[] {
+  if (!text) return [];
+  return text
+    .split(/\n\s*\n/)
+    .map((p) => p.trim())
+    .filter(Boolean)
+    .map((p): ProsePart => {
+      const lines = p.split('\n').map((l) => l.trim()).filter(Boolean);
+      if (lines.every((l) => BULLET.test(l))) return { kind: 'ul', items: lines.map((l) => inlineMarkdown(l.replace(BULLET, ''))) };
+      if (lines.length > 1 && lines.every((l) => NUMBER.test(l))) return { kind: 'ol', items: lines.map((l) => inlineMarkdown(l.replace(NUMBER, ''))) };
+      return { kind: 'p', html: inlineMarkdown(p) };
+    });
+}

package/lib/video.ts

@@ -0,0 +1,75 @@
+/**
+ * Video links → a privacy-friendly embed. Accepts what an editor would paste — a
+ * YouTube watch / share / shorts / live link, a channel's live page, or a Vimeo link —
+ * and returns the embed URL (youtube-nocookie / Vimeo `dnt=1`) plus a link to watch it
+ * on the provider. Anything else → null (the block shows a plain link instead).
+ */
+export interface VideoEmbed {
+  provider: 'YouTube' | 'Vimeo';
+  embedUrl: string;
+  watchUrl: string;
+}
+
+const YT_ID = /^[A-Za-z0-9_-]{11}$/;
+const YT_CHANNEL = /^UC[A-Za-z0-9_-]{22}$/;
+
+export function videoEmbed(input: string | undefined | null): VideoEmbed | null {
+  if (!input) return null;
+  let u: URL;
+  try {
+    u = new URL(input.trim());
+  } catch {
+    return null;
+  }
+  if (u.protocol !== 'https:') return null;
+  const host = u.hostname.replace(/^(www\.|m\.)/, '');
+  const parts = u.pathname.split('/').filter(Boolean);
+  const watchUrl = u.toString();
+
+  if (host === 'youtu.be' && YT_ID.test(parts[0] ?? '')) return yt(parts[0], watchUrl);
+  if (host === 'youtube.com' || host === 'youtube-nocookie.com') {
+    const v = u.searchParams.get('v');
+    if (parts[0] === 'watch' && v && YT_ID.test(v)) return yt(v, watchUrl);
+    if (['embed', 'shorts', 'live', 'v'].includes(parts[0]) && YT_ID.test(parts[1] ?? '')) return yt(parts[1], watchUrl);
+    // A channel's live stream: /channel/<UC…>/live, or an embed of live_stream?channel=…
+    const channel = parts[0] === 'channel' && parts[2] === 'live' ? parts[1] : u.searchParams.get('channel');
+    if (channel && YT_CHANNEL.test(channel)) {
+      return {
+        provider: 'YouTube',
+        embedUrl: `https://www.youtube.com/embed/live_stream?channel=${channel}`,
+        watchUrl: `https://www.youtube.com/channel/${channel}/live`,
+      };
+    }
+    return null;
+  }
+  if (host === 'vimeo.com' && /^\d+$/.test(parts[0] ?? '')) {
+    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[0]}?dnt=1`, watchUrl };
+  }
+  if (host === 'player.vimeo.com' && parts[0] === 'video' && /^\d+$/.test(parts[1] ?? '')) {
+    return { provider: 'Vimeo', embedUrl: `https://player.vimeo.com/video/${parts[1]}?dnt=1`, watchUrl: `https://vimeo.com/${parts[1]}` };
+  }
+  return null;
+}
+
+/**
+ * The same links as a header BACKGROUND: muted, autoplaying, looping and chromeless.
+ * YouTube loops a single video only with `playlist=<id>`; `enablejsapi=1` lets the
+ * hero's pause button send play/pause commands (postMessage, no API script). Vimeo
+ * has a dedicated `background=1` mode. Live streams and hosted files → null (a file
+ * plays in a native <video>).
+ */
+export function backgroundEmbed(input: string | undefined | null): VideoEmbed | null {
+  const v = videoEmbed(input);
+  if (!v || v.embedUrl.includes('live_stream')) return null;
+  if (v.provider === 'Vimeo') return { ...v, embedUrl: v.embedUrl.replace('?dnt=1', '?background=1&dnt=1') };
+  const id = new URL(v.embedUrl).pathname.split('/').pop()!;
+  const q = new URLSearchParams({
+    autoplay: '1', mute: '1', loop: '1', playlist: id, controls: '0', playsinline: '1',
+    rel: '0', disablekb: '1', iv_load_policy: '3', enablejsapi: '1',
+  });
+  return { ...v, embedUrl: `https://www.youtube-nocookie.com/embed/${id}?${q}` };
+}
+
+function yt(id: string, watchUrl: string): VideoEmbed {
+  return { provider: 'YouTube', embedUrl: `https://www.youtube-nocookie.com/embed/${id}?rel=0`, watchUrl };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ferst-core",
-  "version": "0.6.2",
+  "version": "0.7.2",
   "type": "module",
   "description": "Ferst Core — the shared, brand-agnostic client-site system: Astro components, layouts, content schemas, the layered config resolver, and a neutral styling architecture that every client overrides.",
   "license": "BUSL-1.1",