@uniweb/build 0.8.22 → 0.8.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.8.22",
+  "version": "0.8.24",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -54,9 +54,9 @@
     "@uniweb/theming": "0.1.2"
   },
   "optionalDependencies": {
+    "@uniweb/runtime": "0.6.20",
     "@uniweb/content-reader": "1.1.4",
-    "@uniweb/schemas": "0.2.1",
-    "@uniweb/runtime": "0.6.18"
+    "@uniweb/schemas": "0.2.1"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",

package/src/i18n/extract.js

@@ -5,7 +5,7 @@
  * strings and building a manifest of translation units.
  */
 
-import { computeHash } from './hash.js'
+import { computeHash, stripInlineTags } from './hash.js'
 
 /**
  * Extract all translatable units from site content
@@ -250,15 +250,36 @@ function extractFromList(listNode, context, units) {
 }
 
 /**
- * Extract all text content from a node
+ * Extract all text content from a node.
+ * When a node has multiple text children with some carrying span marks
+ * (e.g., `[text]{accent}`), wraps the marked spans in XLIFF-style
+ * `<N>...</N>` tags so translators can reposition them.
  */
 function extractTextFromNode(node) {
   if (!node.content) return ''
-  return node.content
-    .filter(n => n.type === 'text')
-    .map(n => n.text || '')
-    .join('')
-    .trim()
+  const textChildren = node.content.filter(n => n.type === 'text')
+
+  // Check for mixed inline marks (span marks from `[text]{class}` syntax)
+  const hasInlineMarks = textChildren.length > 1 &&
+    textChildren.some(n => n.marks?.some(m => m.type === 'span'))
+
+  if (!hasInlineMarks) {
+    return textChildren.map(n => n.text || '').join('').trim()
+  }
+
+  // Wrap span-marked text in numbered tags
+  let markCounter = 0
+  const parts = []
+  for (const child of textChildren) {
+    const text = child.text || ''
+    if (child.marks?.some(m => m.type === 'span')) {
+      markCounter++
+      parts.push(`<${markCounter}>${text}</${markCounter}>`)
+    } else {
+      parts.push(text)
+    }
+  }
+  return parts.join('').trim()
 }
 
 /**
@@ -267,7 +288,8 @@ function extractTextFromNode(node) {
 function addUnit(units, source, field, context) {
   if (!source || source.length === 0) return
 
-  const hash = computeHash(source)
+  // Hash on plain text (strip inline tags) so keys stay stable
+  const hash = computeHash(stripInlineTags(source))
 
   if (units[hash]) {
     // Unit exists - add context if not already present

package/src/i18n/hash.js

@@ -28,3 +28,47 @@ export function normalizeText(text) {
   if (typeof text !== 'string') return ''
   return text.trim().replace(/\s+/g, ' ')
 }
+
+/**
+ * Strip inline mark tags for hashing: "<1>text</1>" → "text"
+ * Used to keep hash keys stable regardless of mark tagging.
+ * @param {string} text
+ * @returns {string}
+ */
+export function stripInlineTags(text) {
+  if (typeof text !== 'string') return ''
+  return text.replace(/<\/?(\d+)>/g, '')
+}
+
+/**
+ * Parse tagged translation string into segments.
+ * "plain <1>marked</1> more" →
+ *   { segments: [{ text: "plain " }, { text: "marked", markIndex: 0 }, { text: " more" }], hasMarks: true }
+ *
+ * Tag numbers are 1-based in the string, markIndex is 0-based in the result.
+ * @param {string} text
+ * @returns {{ segments: Array<{ text: string, markIndex?: number }>, hasMarks: boolean }}
+ */
+export function parseInlineTags(text) {
+  const regex = /<(\d+)>([\s\S]*?)<\/\1>/g
+  const segments = []
+  let lastIndex = 0
+  let hasMarks = false
+  let match
+
+  while ((match = regex.exec(text)) !== null) {
+    hasMarks = true
+    if (match.index > lastIndex) {
+      segments.push({ text: text.slice(lastIndex, match.index) })
+    }
+    segments.push({ text: match[2], markIndex: parseInt(match[1], 10) - 1 })
+    lastIndex = regex.lastIndex
+  }
+
+  if (lastIndex < text.length) {
+    segments.push({ text: text.slice(lastIndex) })
+  }
+
+  if (!hasMarks) return { segments: [{ text }], hasMarks: false }
+  return { segments, hasMarks }
+}

package/src/i18n/merge.js

@@ -12,7 +12,7 @@
  * when no free-form translation exists.
  */
 
-import { computeHash } from './hash.js'
+import { computeHash, stripInlineTags, parseInlineTags } from './hash.js'
 import { loadFreeformTranslation } from './freeform.js'
 
 /**
@@ -264,27 +264,88 @@ function translateProseMirrorDoc(doc, context, translations, fallbackToSource) {
 }
 
 /**
- * Recursively translate a node and its children
+ * Recursively translate a node and its children.
+ * For nodes with mixed marked/unmarked text children (inline span marks),
+ * translates the node as a whole unit using XLIFF-style inline tags,
+ * then rebuilds children with original marks re-applied.
  */
 function translateNode(node, context, translations, fallbackToSource) {
-  // Translate text content
-  if (node.content) {
-    for (const child of node.content) {
-      if (child.type === 'text' && child.text) {
-        const translated = lookupTranslation(
-          child.text,
-          context,
-          translations,
-          fallbackToSource
-        )
-        if (translated !== child.text) {
-          child.text = translated
-        }
+  if (!node.content) return
+
+  // Check for inline span marks across multiple text children
+  const textChildren = node.content.filter(n => n.type === 'text')
+  const hasInlineMarks = textChildren.length > 1 &&
+    textChildren.some(n => n.marks?.some(m => m.type === 'span'))
+
+  if (hasInlineMarks) {
+    // Build tagged source string (mirrors extraction)
+    let markCounter = 0
+    const markMap = [] // tag index → original marks array
+    const parts = []
+    for (const child of textChildren) {
+      const text = child.text || ''
+      if (child.marks?.some(m => m.type === 'span')) {
+        markCounter++
+        markMap.push(child.marks)
+        parts.push(`<${markCounter}>${text}</${markCounter}>`)
       } else {
-        // Recurse into child nodes
+        parts.push(text)
+      }
+    }
+    const plainSource = stripInlineTags(parts.join('').trim())
+
+    const translated = lookupTranslation(plainSource, context, translations, fallbackToSource)
+    if (translated !== plainSource) {
+      // Parse tagged translation and rebuild text children
+      const { segments } = parseInlineTags(translated)
+      const newTextChildren = segments.map(seg => {
+        if (seg.markIndex !== undefined && markMap[seg.markIndex]) {
+          return { type: 'text', text: seg.text, marks: [...markMap[seg.markIndex]] }
+        }
+        return { type: 'text', text: seg.text }
+      })
+
+      // Replace text children in content, preserve non-text children in place
+      const result = []
+      let textInserted = false
+      for (const child of node.content) {
+        if (child.type === 'text') {
+          if (!textInserted) {
+            result.push(...newTextChildren)
+            textInserted = true
+          }
+          // Skip remaining old text children
+        } else {
+          result.push(child)
+        }
+      }
+      node.content = result
+    }
+
+    // Recurse into non-text children
+    for (const child of node.content) {
+      if (child.type !== 'text') {
         translateNode(child, context, translations, fallbackToSource)
       }
     }
+    return
+  }
+
+  // Default: translate each child individually
+  for (const child of node.content) {
+    if (child.type === 'text' && child.text) {
+      const translated = lookupTranslation(
+        child.text,
+        context,
+        translations,
+        fallbackToSource
+      )
+      if (translated !== child.text) {
+        child.text = translated
+      }
+    } else {
+      translateNode(child, context, translations, fallbackToSource)
+    }
   }
 }
 

package/src/runtime-schema.js

@@ -309,6 +309,7 @@ export function extractAllRuntimeSchemas(componentsMeta) {
  * - areas: Array of area names this layout supports
  * - transitions: View transition name mapping (stored but not acted on yet)
  * - defaults: Param default values
+ * - scroll: Scroll management mode ('self' or CSS selector)
  *
  * @param {Object} fullMeta - The full meta.js default export for a layout
  * @returns {Object|null} - Lean layout runtime schema or null if empty
@@ -328,6 +329,10 @@ export function extractLayoutRuntimeSchema(fullMeta) {
     runtime.transitions = fullMeta.transitions
   }
 
+  if (fullMeta.scroll !== undefined) {
+    runtime.scroll = fullMeta.scroll
+  }
+
   const defaults = extractParamDefaults(fullMeta.params)
   if (defaults) {
     runtime.defaults = defaults

package/src/site/plugin.js

@@ -942,10 +942,17 @@ export function siteContentPlugin(options = {}) {
         headInjection += `    <script type="application/json" id="${variableName}">${JSON.stringify(contentToInject).replace(/</g, '\\u003c')}</script>\n`
       }
 
-      if (!headInjection) return html
+      let result = html
+
+      // Update <html lang> for non-default locales
+      if (activeLocale) {
+        result = result.replace(/<html([^>]*)\slang="[^"]*"/, `<html$1 lang="${activeLocale}"`)
+      }
+
+      if (!headInjection) return result
 
       // Insert before </head>
-      return html.replace('</head>', headInjection + '  </head>')
+      return result.replace('</head>', headInjection + '  </head>')
     },
 
     async generateBundle() {