@vojtaholik/static-kit-core 2.1.1 → 2.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vojtaholik/static-kit-core",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "type": "module",
   "exports": {
     ".": {

package/src/html-renderer.ts

@@ -3,6 +3,7 @@ import type { LayoutProps } from "./layout.ts";
 import { layoutPropsSchema } from "./layout.ts";
 import { blockRegistry, type RenderContext } from "./block-registry.ts";
 import type { SchemaAddress } from "./schema-address.ts";
+import { vlnaHtml } from "./vlna.ts";
 
 /**
  * Augmentable block props map — users register their block types via:
@@ -161,6 +162,9 @@ export async function renderPage(
     html = html.replace(marker, content);
   }
 
+  // Czech typography: non-breaking spaces after single-char prepositions
+  html = vlnaHtml(html);
+
   // Inject dev overlay if in dev mode
   if (options.isDev) {
     html = injectDevOverlay(html);

package/src/index.ts

@@ -54,5 +54,8 @@ export {
   type CompileOptions,
 } from "./template-compiler.ts";
 
+// Czech typography (vlna)
+export { vlna, vlnaHtml, preventWidow } from "./vlna.ts";
+
 // Configuration
 export { configSchema, defineConfig, type StaticKitConfig } from "./config.ts";

package/src/vlna.ts

@@ -0,0 +1,123 @@
+/**
+ * Czech typography transform (vlna)
+ *
+ * Inserts non-breaking spaces (\u00A0) after single-character Czech
+ * prepositions and conjunctions (k, s, v, z, o, u, a, i) so they
+ * never end up alone at the end of a line.
+ *
+ * Also prevents widows — a single short word orphaned on the last
+ * line of a paragraph.
+ *
+ * Runs at build time. The util itself is never shipped to browsers;
+ * only the resulting \u00A0 characters are baked into the HTML output.
+ *
+ * Based on ČSN 01 6910 and Petr Olšák's vlna for TeX.
+ */
+
+/**
+ * Single-char Czech prepositions/conjunctions: k s v z o u a i
+ * Uses lookbehind so the leading whitespace isn't consumed — handles
+ * adjacent prepositions like "v s tím" in a single pass.
+ * Only replaces regular spaces (not existing \u00A0).
+ */
+const SINGLE_CHAR_RE = /(?<=\s|^)([ksvzouaiKSVZOUAI]) /g;
+
+/**
+ * Short (2–3 char) Czech prepositions that shouldn't end a line.
+ * Case-insensitive match at word boundary.
+ */
+const SHORT_PREP_RE =
+  /(?<=\s|^)(bez|nad|pod|pro|při|přes|před|mezi|jako|ani|ale|nebo|Bez|Nad|Pod|Pro|Při|Přes|Před|Mezi|Jako|Ani|Ale|Nebo|BEZ|NAD|POD|PRO|PŘI|PŘES|PŘED|MEZI|JAKO|ANI|ALE|NEBO|do|ke|ku|na|od|po|se|ve|za|ze|Do|Ke|Ku|Na|Od|Po|Se|Ve|Za|Ze|DO|KE|KU|NA|OD|PO|SE|VE|ZA|ZE) /g;
+
+/**
+ * Replace space after Czech prepositions/conjunctions with \u00A0.
+ * Handles single-char (k, s, v…) and short words (bez, nad, pro…).
+ * Plain text only — no HTML awareness.
+ */
+export function vlna(text: string): string {
+  return text
+    .replace(SINGLE_CHAR_RE, "$1\u00A0")
+    .replace(SHORT_PREP_RE, "$1\u00A0");
+}
+
+/**
+ * Prevent widows — replace the last space in a text with \u00A0
+ * so the final word doesn't sit alone on a line.
+ * Only acts when the last word is ≤15 chars (avoids gluing long URLs etc).
+ */
+export function preventWidow(text: string): string {
+  return text.replace(/\s(\S{1,15})\s*$/, "\u00A0$1");
+}
+
+/** Tags whose text content should NOT be transformed */
+const SKIP_TAGS = new Set([
+  "script",
+  "style",
+  "code",
+  "pre",
+  "textarea",
+  "kbd",
+  "var",
+  "samp",
+  "title",
+]);
+
+/**
+ * Apply Czech typography transforms to all text nodes in an HTML string.
+ * Skips content inside <script>, <style>, <code>, <pre>, <textarea>, etc.
+ * Does not touch HTML tags or attributes — only text between > and <.
+ */
+export function vlnaHtml(html: string): string {
+  // Track which tags we're inside to know when to skip
+  const tagStack: string[] = [];
+  let result = "";
+  let i = 0;
+
+  while (i < html.length) {
+    if (html[i] === "<") {
+      // Find end of tag
+      const tagEnd = html.indexOf(">", i);
+      if (tagEnd === -1) {
+        // Malformed HTML — just append rest
+        result += html.slice(i);
+        break;
+      }
+
+      const tag = html.slice(i, tagEnd + 1);
+      result += tag;
+
+      // Parse tag name
+      const tagMatch = tag.match(/^<\/?([a-zA-Z][a-zA-Z0-9-]*)/);
+      if (tagMatch) {
+        const tagName = tagMatch[1]!.toLowerCase();
+        if (tag[1] === "/") {
+          // Closing tag — pop from stack
+          const idx = tagStack.lastIndexOf(tagName);
+          if (idx !== -1) tagStack.splice(idx, 1);
+        } else if (!tag.endsWith("/>")) {
+          // Opening tag (not self-closing)
+          tagStack.push(tagName);
+        }
+      }
+
+      i = tagEnd + 1;
+    } else {
+      // Text node — find the next tag
+      const nextTag = html.indexOf("<", i);
+      const textEnd = nextTag === -1 ? html.length : nextTag;
+      const text = html.slice(i, textEnd);
+
+      // Only transform if we're not inside a skip tag
+      const inSkipTag = tagStack.some((t) => SKIP_TAGS.has(t));
+      if (inSkipTag) {
+        result += text;
+      } else {
+        result += preventWidow(vlna(text));
+      }
+
+      i = textEnd;
+    }
+  }
+
+  return result;
+}