@stnd/modules 0.5.1

package/mermaid/client.js

@@ -0,0 +1,125 @@
+/**
+ * Mermaid Module — Client Initializer
+ *
+ * Standalone module that detects and renders Mermaid diagrams.
+ * Decoupled from the markdown renderer.
+ *
+ * Theme-aware: Uses native CSS variables via styles.css for instant color transitions.
+ */
+
+const MERMAID_CDN =
+  "https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs";
+
+let mermaidLib = null;
+
+async function loadMermaid() {
+  if (mermaidLib) return mermaidLib;
+  if (window.mermaid) {
+    mermaidLib = window.mermaid;
+    return mermaidLib;
+  }
+  try {
+    const mod = await import(/* @vite-ignore */ MERMAID_CDN);
+    mermaidLib = mod.default;
+    window.mermaid = mermaidLib;
+    return mermaidLib;
+  } catch (err) {
+    console.error("[Mermaid] Failed to load from CDN:", err);
+    throw err;
+  }
+}
+
+function resolveFont(name, fallback) {
+  if (typeof window === "undefined") return fallback;
+  const raw = getComputedStyle(document.documentElement)
+    .getPropertyValue(name)
+    .trim();
+  return raw || fallback;
+}
+
+/**
+ * Clean up characters corrupted by typography post-processing or editors.
+ */
+function cleanMermaidCode(raw) {
+  return raw
+    .trim()
+    .replace(/[\u201C\u201D]/g, '"')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/\u2192/g, "->")
+    .replace(/\u2190/g, "<-")
+    .replace(/\u2014>/g, "-->")
+    .replace(/\u2014/g, "--")
+    .replace(/\u2013/g, "-")
+    .replace(/\u2026/g, "...")
+    .replace(/-&gt;/g, "->")
+    .replace(/&lt;-/g, "<-")
+    .replace(/&amp;/g, "&")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+}
+
+/**
+ * Render a single diagram into a container.
+ * Returns the container element (or null on failure).
+ */
+async function renderOne(lib, code, index) {
+  try {
+    const { svg } = await lib.render(`mmd-${Date.now()}-${index}`, code);
+    const container = document.createElement("div");
+    container.className = "mermaid-rendered";
+    container.dataset.mermaidSource = code;
+    container.innerHTML = svg;
+    return container;
+  } catch (err) {
+    console.error("[Mermaid] Render error:", err);
+    return null;
+  }
+}
+
+/**
+ * First-pass render: find unprocessed code blocks and render them.
+ */
+async function renderMermaid() {
+  const blocks = document.querySelectorAll(
+    ".mermaid:not([data-mermaid-processed]), pre code.language-mermaid:not([data-mermaid-processed])",
+  );
+  if (blocks.length === 0) return;
+
+  let lib;
+  try {
+    lib = await loadMermaid();
+  } catch (err) {
+    return;
+  }
+
+  lib.initialize({
+    startOnLoad: false,
+    theme: "base",
+    securityLevel: "loose",
+    fontFamily: resolveFont("--font-monospace", "sans-serif"),
+  });
+
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i];
+    block.setAttribute("data-mermaid-processed", "true");
+
+    const code = cleanMermaidCode(block.textContent || "");
+    if (!code) continue;
+
+    const container = await renderOne(lib, code, i);
+    if (container) {
+      const pre = block.closest("pre");
+      (pre || block).replaceWith(container);
+    }
+  }
+}
+
+// ── Exports ──────────────────────────────────────────────────────
+
+export function init() {
+  renderMermaid();
+}
+
+export function refresh() {
+  renderMermaid();
+}

package/mermaid/index.module.js

@@ -0,0 +1,19 @@
+/**
+ * Mermaid Module — Standalone diagram and flowchart rendering.
+ *
+ * Scans the page for Mermaid syntax and renders it via Mermaid.js.
+ */
+
+export default {
+  id: "mermaid",
+  name: "Mermaid",
+  description: "Diagram and flowchart rendering with Mermaid.js",
+
+  styles: ["./styles.css"],
+  scripts: [{ src: "./client.js", init: "init", refresh: "refresh" }],
+
+  metadata: {
+    version: "1.0.0",
+    tags: ["diagram", "mermaid", "flowchart"],
+  },
+};

package/mermaid/styles.css

@@ -0,0 +1,114 @@
+/* Mermaid Module Styles
+ *
+ * Mermaid renders SVGs with inline styles using themeVariables from client.js.
+ * These CSS rules handle layout and container cleanup, and override colors
+ * with CSS custom properties so that theme transitions are instant and native.
+ */
+
+.stnd-code-block:has(.mermaid-rendered),
+.mermaid-rendered {
+  text-box-trim: none !important;
+  background: transparent;
+  box-shadow: none;
+}
+
+.mermaid-rendered {
+  text-box-trim: none !important;
+  text-align: center;
+
+  foreignObject {
+    overflow: visible;
+  }
+}
+
+/* ── Instant CSS Variable Overrides ─────────────────────────────────────── */
+/* Node fills and borders */
+.mermaid-rendered svg .node rect,
+.mermaid-rendered svg .node circle,
+.mermaid-rendered svg .node ellipse,
+.mermaid-rendered svg .node polygon,
+.mermaid-rendered svg .node path {
+  fill: var(--color-surface) !important;
+  stroke: var(--color-border) !important;
+}
+
+/* Cluster/subgraph backgrounds */
+.mermaid-rendered svg .cluster rect {
+  fill: var(--color-background) !important;
+  stroke: var(--color-border) !important;
+}
+
+/* Edges and lines */
+.mermaid-rendered svg .edgePath .path,
+.mermaid-rendered svg .flowchart-link {
+  stroke: var(--color-border) !important;
+}
+
+/* Arrowheads/markers */
+.mermaid-rendered svg marker path {
+  fill: var(--color-border) !important;
+  stroke: var(--color-border) !important;
+}
+
+/* Text / labels */
+.mermaid-rendered svg .label text,
+.mermaid-rendered svg .nodeLabel,
+.mermaid-rendered svg .edgeLabel,
+.mermaid-rendered svg .cluster-label text,
+.mermaid-rendered svg .edgeLabel p,
+.mermaid-rendered svg .edgeLabel span,
+.mermaid-rendered svg .nodeLabel p,
+.mermaid-rendered svg .nodeLabel span {
+  fill: var(--color-foreground) !important;
+  color: var(--color-foreground) !important;
+}
+
+.mermaid-rendered svg .edgeLabel,
+.mermaid-rendered svg .edgeLabel div,
+.mermaid-rendered svg .edgeLabel span,
+.mermaid-rendered svg .edgeLabel p,
+.mermaid-rendered svg .edgeTerminals {
+  background-color: var(--color-background) !important;
+}
+
+.mermaid-rendered svg .edgeLabel rect {
+  fill: var(--color-background) !important;
+}
+
+/* Sequence diagrams */
+.mermaid-rendered svg .actor {
+  fill: var(--color-surface) !important;
+  stroke: var(--color-border) !important;
+}
+.mermaid-rendered svg text.actor > tspan {
+  fill: var(--color-foreground) !important;
+}
+.mermaid-rendered svg .actor-line {
+  stroke: var(--color-border) !important;
+}
+.mermaid-rendered svg .messageLine0,
+.mermaid-rendered svg .messageLine1 {
+  stroke: var(--color-border) !important;
+}
+.mermaid-rendered svg #arrowhead path,
+.mermaid-rendered svg #crosshead path,
+.mermaid-rendered svg #filled-head path {
+  fill: var(--color-border) !important;
+  stroke: none !important;
+}
+.mermaid-rendered svg .messageText {
+  fill: var(--color-foreground) !important;
+  stroke: none !important;
+}
+.mermaid-rendered svg .note {
+  fill: var(--color-surface) !important;
+  stroke: var(--color-border) !important;
+}
+.mermaid-rendered svg .noteText > tspan {
+  fill: var(--color-foreground) !important;
+}
+
+/* Default SVG text fallback */
+.mermaid-rendered svg text {
+  fill: var(--color-foreground) !important;
+}

package/p5/client.js

@@ -0,0 +1,25 @@
+/**
+ * p5 Module — Client accessor
+ *
+ * The p5.js UMD build is preloaded in <head> by the module manifest's
+ * scripts: field, so window.p5 is available by the time any Svelte island
+ * mounts. No async fetch needed.
+ *
+ * @example
+ * import { getP5 } from "@stnd/modules/p5/client.js";
+ *
+ * onMount(() => {
+ *   const p5 = getP5();
+ *   instance = new p5(sketch, container);
+ * });
+ */
+
+/**
+ * Return the p5 constructor from window.
+ * Must be called inside onMount (browser only).
+ * @returns {typeof p5}
+ */
+export function getP5() {
+  if (!window.p5) throw new Error("[p5] window.p5 not found — is the p5 module loaded?");
+  return window.p5;
+}

package/p5/index.module.js

@@ -0,0 +1,24 @@
+/**
+ * p5 Module — Creative coding with p5.js
+ *
+ * Provides a CDN-backed lazy loader for p5.js.
+ * No bundling — p5 is loaded at runtime from jsDelivr.
+ *
+ * Usage in components:
+ *   import { loadP5 } from "@stnd/modules/p5/client.js";
+ */
+
+export default {
+  id: "p5",
+  name: "p5",
+  description: "Creative coding with p5.js — preloaded from CDN, available as window.p5",
+
+  // UMD build: loads in <head> in parallel with the page, sets window.p5.
+  // By the time a Svelte island mounts, window.p5 is already available.
+  scripts: ["https://cdn.jsdelivr.net/npm/p5@1/lib/p5.min.js"],
+
+  metadata: {
+    version: "1.0.0",
+    tags: ["canvas", "creative-coding", "p5", "generative-art"],
+  },
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@stnd/modules",
+  "version": "0.5.1",
+  "type": "module",
+  "svelte": "./stripe/views/CheckoutView.svelte",
+  "author": "Francis Fontaine",
+  "license": "MIT",
+  "exports": {
+    ".": "./toast/index.module.js",
+    "./*": {
+      "astro": "./*.astro",
+      "svelte": "./*.svelte",
+      "js": "./*.js",
+      "default": "./*/index.module.js"
+    },
+    "./*/*": "./*/*"
+  },
+  "dependencies": {
+    "@astrojs/sitemap": "^3.7.3",
+    "wrangler": "^4.105.0",
+    "@stnd/icon": "0.2.0",
+    "@stnd/log": "0.5.0",
+    "@stnd/styles": "0.5.2",
+    "@stnd/utils": "0.5.0"
+  },
+  "peerDependencies": {
+    "astro": ">=5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@better-auth/cli": "^1.4.21"
+  }
+}

package/prism/README.md

@@ -0,0 +1,13 @@
+# Prism Syntax Highlighting Module
+
+This module loads Prism.js and Prism.css from CDN and ensures syntax highlighting is applied to all code blocks on initial load and after every Astro navigation ("astro:after-swap").
+
+## Usage
+
+- Register this module in your app's module manifest.
+- All code blocks with appropriate language classes will be highlighted automatically.
+
+## CDN Versions
+
+- Prism.js v1.29.0
+- Prism.css v1.29.0

package/prism/index.module.js

@@ -0,0 +1,19 @@
+/**
+ * Prism Syntax Highlighting Module
+ * Loads Prism.js and Prism.css from CDN and highlights code blocks on every page change.
+ *
+ *
+ * ,
+ styles: [
+   "https://cdnjs.cloudflare.com/ajax/libs/prism/1.29.0/themes/prism.min.css",
+ ],
+ */
+export default {
+  id: "stnd-prism",
+  name: "Stnd :: Prism Syntax Highlighting",
+  scripts: [
+    "https://cdnjs.cloudflare.com/ajax/libs/prism/1.30.0/prism.min.js",
+    "https://cdnjs.cloudflare.com/ajax/libs/prism/1.30.0/plugins/autoloader/prism-autoloader.min.js",
+    { src: "@stnd/client/prism", init: "initPrism", refresh: "refreshPrism" },
+  ],
+};

package/robots/index.module.js

@@ -0,0 +1,16 @@
+/**
+ * Robots.txt core module
+ *
+ * Exposes the /robots.txt route via the Standard module system.
+ */
+export default {
+  id: "stnd-robots",
+  name: "Stnd :: Robots",
+  routes: [
+    {
+      path: "/robots.txt",
+      entrypoint: "./route.js",
+    },
+  ],
+  description: "Serves robots.txt based on site configuration.",
+};

package/robots/route.js

@@ -0,0 +1,67 @@
+import config from "virtual:stnd/config";
+
+export async function GET(context) {
+  const robots = config.robots || {};
+  if (robots.enabled === false) {
+    return new Response(null, { status: 404 });
+  }
+
+  const site = context.site ? context.site.toString() : "https://example.com";
+  const userAgent = robots.userAgent || "*";
+  const disallow = robots.disallow || ["/admin/", "/private/"];
+  const allow = robots.allow || [];
+  const customRules = robots.customRules || [];
+  const crawlDelay = robots.crawlDelay;
+  const sitemapUrl =
+    robots.sitemapUrl ||
+    (context.site ? new URL("sitemap.xml", context.site).href : null);
+
+  let content = `# robots.txt for ${site}
+# Generated by Standard Framework
+
+User-agent: ${userAgent}
+`;
+
+  if (disallow.length > 0) {
+    disallow.forEach((p) => {
+      content += `Disallow: ${p}
+`;
+    });
+  } else {
+    content += `Disallow:
+`;
+  }
+
+  allow.forEach((p) => {
+    content += `Allow: ${p}
+`;
+  });
+
+  if (crawlDelay) {
+    content += `Crawl-delay: ${crawlDelay}
+`;
+  }
+
+  if (customRules.length > 0) {
+    content += `
+# Custom rules
+`;
+    customRules.forEach((rule) => {
+      content += `${rule}
+`;
+    });
+  }
+
+  if (sitemapUrl) {
+    content += `
+# Sitemap
+Sitemap: ${sitemapUrl}
+`;
+  }
+
+  return new Response(content, {
+    headers: {
+      "Content-Type": "text/plain",
+    },
+  });
+}

package/rss/index.module.js

@@ -0,0 +1,18 @@
+/**
+ * RSS/Atom Feed core module
+ *
+ * Exposes the /rss.xml route via the Standard module system.
+ * Auto-generates a feed from content collections and site config.
+ */
+export default {
+  id: "stnd-rss",
+  name: "Stnd :: RSS",
+  description:
+    "Generates an RSS/Atom feed from site content and configuration.",
+  routes: [
+    {
+      path: "/rss.xml",
+      entrypoint: "./route.js",
+    },
+  ],
+};

package/rss/route.js

@@ -0,0 +1,163 @@
+import config from "virtual:stnd/config";
+// @ts-ignore
+import { runHook } from "virtual:stnd/hooks";
+
+/**
+ * RSS 2.0 Feed Route
+ *
+ * Generates a standards-compliant RSS feed.
+ * Aggregates items from:
+ * 1. Static config (config.rss.items)
+ * 2. Dynamic hook (stnd:rss:register)
+ */
+
+function escapeXml(str) {
+  if (!str) return "";
+  return String(str)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function formatRfc822Date(input) {
+  if (!input) return null;
+  const date = input instanceof Date ? input : new Date(input);
+  if (isNaN(date.getTime())) return null;
+  return date.toUTCString();
+}
+
+export async function GET(context) {
+  const rss = config.rss || {};
+  if (rss.enabled === false) {
+    return new Response(null, { status: 404 });
+  }
+
+  const site = context.site
+    ? context.site.toString().replace(/\/$/, "")
+    : config.url?.replace(/\/$/, "") || "https://example.com";
+
+  // 1. Collect Items
+  // --- Static items from config
+  const staticItems = rss.items || [];
+
+  // --- Dynamic items via Hook
+  let dynamicItems = [];
+  try {
+    const hookResults = await runHook("stnd:rss:register");
+    dynamicItems = hookResults.flat().filter(Boolean);
+  } catch (e) {
+    console.error("[RSS] Hook stnd:rss:register failed:", e);
+  }
+
+  // 2. Merge, Sort and Limit
+  const allItems = [...staticItems, ...dynamicItems]
+    .map((item) => ({
+      ...item,
+      parsedDate: item.pubDate ? new Date(item.pubDate) : new Date(0),
+    }))
+    .sort((a, b) => b.parsedDate.getTime() - a.parsedDate.getTime())
+    .slice(0, rss.limit || 50);
+
+  const title = rss.title || config.title || "Untitled Site";
+  const description = rss.description || config.description || "";
+  const language = rss.language || config.language || "fr";
+  const copyright = rss.copyright || "";
+  const managingEditor = rss.managingEditor || "";
+  const webMaster = rss.webMaster || "";
+  const ttl = rss.ttl || 60;
+  const categories = rss.categories || [];
+
+  const feedUrl = new URL("/rss.xml", site).href;
+  const lastBuildDate = formatRfc822Date(new Date());
+
+  let xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0"
+  xmlns:atom="http://www.w3.org/2005/Atom"
+  xmlns:content="http://purl.org/rss/1.0/modules/content/"
+  xmlns:media="http://search.yahoo.com/mrss/"
+  xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <channel>
+    <title>${escapeXml(title)}</title>
+    <link>${escapeXml(site)}</link>
+    <description>${escapeXml(description)}</description>
+    <language>${escapeXml(language)}</language>
+    <lastBuildDate>${lastBuildDate}</lastBuildDate>
+    <atom:link href="${escapeXml(feedUrl)}" rel="self" type="application/rss+xml" />
+    <generator>Standard Framework</generator>
+    <ttl>${ttl}</ttl>
+`;
+
+  if (copyright) {
+    xml += `    <copyright>${escapeXml(copyright)}</copyright>\n`;
+  }
+  if (managingEditor) {
+    xml += `    <managingEditor>${escapeXml(managingEditor)}</managingEditor>\n`;
+  }
+  if (webMaster) {
+    xml += `    <webMaster>${escapeXml(webMaster)}</webMaster>\n`;
+  }
+  for (const cat of categories) {
+    xml += `    <category>${escapeXml(cat)}</category>\n`;
+  }
+
+  for (const item of allItems) {
+    const itemLink = item.link
+      ? item.link.startsWith("http")
+        ? item.link
+        : new URL(item.link, site).href
+      : "";
+    const itemGuid = item.guid
+      ? item.guid.startsWith("http")
+        ? item.guid
+        : new URL(item.guid, site).href
+      : itemLink;
+    const pubDate = formatRfc822Date(item.pubDate);
+    const itemCategories = item.categories || item.tags || [];
+
+    xml += `    <item>
+      <title>${escapeXml(item.title || "Untitled")}</title>
+      <link>${escapeXml(itemLink)}</link>
+      <guid isPermaLink="true">${escapeXml(itemGuid)}</guid>
+`;
+    if (item.description) {
+      xml += `      <description>${escapeXml(item.description)}</description>\n`;
+    }
+    if (item.content) {
+      xml += `      <content:encoded><![CDATA[${item.content}]]></content:encoded>\n`;
+    }
+    if (pubDate) {
+      xml += `      <pubDate>${pubDate}</pubDate>\n`;
+    }
+    if (item.author) {
+      xml += `      <dc:creator>${escapeXml(item.author)}</dc:creator>\n`;
+    }
+
+    // Support for Images (Media RSS & Enclosure)
+    if (item.image) {
+      const imgUrl = item.image.startsWith("http")
+        ? item.image
+        : new URL(item.image, site).href;
+      xml += `      <enclosure url="${escapeXml(imgUrl)}" length="0" type="image/jpeg" />\n`;
+      xml += `      <media:content url="${escapeXml(imgUrl)}" medium="image" />\n`;
+    }
+
+    for (const cat of itemCategories) {
+      xml += `      <category>${escapeXml(cat)}</category>\n`;
+    }
+
+    xml += `    </item>\n`;
+  }
+
+  xml += `  </channel>
+</rss>
+`;
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+      "Cache-Control": "public, max-age=3600, stale-while-revalidate=86400",
+    },
+  });
+}

package/scroll-wrappers/index.module.js

@@ -0,0 +1,9 @@
+/**
+ * Scroll Wrappers Module
+ * Client script lives in @stnd/client — manifest registered here.
+ */
+export default {
+  id: "stnd-scroll-wrappers",
+  name: "Stnd :: Client :: Scroll Wrappers",
+  scripts: [{ src: "@stnd/client/scroll-wrappers", init: "initScrollWrappers", refresh: "refreshScrollWrappers" }],
+};

package/security-txt/index.module.js

@@ -0,0 +1,17 @@
+/**
+ * security.txt core module
+ *
+ * Serves /.well-known/security.txt per RFC 9116.
+ * Configurable via standard({ security: { securityTxt: { ... } } }).
+ */
+export default {
+  id: "stnd-security-txt",
+  name: "Stnd :: security.txt",
+  description: "Serves /.well-known/security.txt per RFC 9116.",
+  routes: [
+    {
+      path: "/.well-known/security.txt",
+      entrypoint: "./route.js",
+    },
+  ],
+};