@uniweb/build 0.80.1 → 0.80.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.80.1",
+  "version": "0.80.2",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -58,10 +58,10 @@
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
     "@uniweb/content-reader": "^1.2.8",
-    "@uniweb/semantic-parser": "^1.5.1",
-    "@uniweb/projections": "^0.7.15",
-    "@uniweb/schemas": "^0.13.0",
     "@uniweb/content-writer": "^0.3.4",
+    "@uniweb/schemas": "^0.13.0",
+    "@uniweb/projections": "^0.7.15",
+    "@uniweb/semantic-parser": "^1.5.1",
     "@uniweb/theming": "^0.2.0"
   },
   "optionalDependencies": {
@@ -74,8 +74,8 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.38.0",
-    "@uniweb/runtime": "^0.29.4"
+    "@uniweb/runtime": "^0.29.4",
+    "@uniweb/core": "^0.38.0"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/i18n/merge.js

@@ -443,7 +443,7 @@ function linkRuns(source) {
         runs.push({ link, marks: [...node.marks], before: gap })
       }
       gap = []
-    } else if (node.type === 'hardBreak' || (node.type === 'text' && !node.marks?.length && !node.text?.trim())) {
+    } else if (isGap(node)) {
       gap.push(node)
     } else {
       return null
@@ -452,6 +452,49 @@ function linkRuns(source) {
   return runs.length ? runs : null
 }
 
+// What may sit between two links of an element made only of links: a line break, or spaces.
+function isGap(node) {
+  return node.type === 'hardBreak' || (node.type === 'text' && !node.marks?.length && !node.text?.trim())
+}
+
+/**
+ * The labels of a translated element made only of links — `asLinkLabels` the other way, for a
+ * pull: one run of the target's own nodes per link of the source's, each without the marks its
+ * link carries. Null when the source is not only links, or the target's links are not the source's
+ * own, one to one and in order.
+ *
+ * ⚠️ It does not ask whether the merge reads the labels back to the target — a caller does
+ * (`uwx/locale-sync.js`), since only then are they the same translation.
+ *
+ * @param {Array} source - the element's source inline content
+ * @param {Array} target - the element's translated inline content
+ * @returns {Array<Array>|null} each link's label, as inline nodes
+ */
+export function linkLabels(source, target) {
+  const links = linkRuns(source)
+  if (!links) return null
+  const labels = []
+  let current = null
+  for (const node of target || []) {
+    if (!node) continue
+    const link = linkMarkOf(node)
+    if (link) {
+      if (!current || !sameMark(current, link)) {
+        const next = links[labels.length]
+        if (!next || !sameMark(next.link, link)) return null
+        labels.push([])
+        current = link
+      }
+      labels[labels.length - 1].push(withoutMarks(node, links[labels.length - 1].marks))
+    } else if (isGap(node)) {
+      current = null
+    } else {
+      return null
+    }
+  }
+  return labels.length === links.length ? labels : null
+}
+
 function linkMarkOf(node) {
   return node?.type === 'text' ? node.marks?.find((mark) => mark.type === 'link') || null : null
 }
@@ -493,6 +536,13 @@ function withMarks(node, marks) {
   return { ...node, marks: [...marks, ...own] }
 }
 
+// A label node without its link's marks — `withMarks` the other way.
+function withoutMarks(node, marks) {
+  const own = (node.marks || []).filter((mark) => !marks.some((linkMark) => linkMark.type === mark.type))
+  const { marks: _linkMarks, ...rest } = node
+  return own.length ? { ...rest, marks: own } : rest
+}
+
 /**
  * Translate the human-readable strings inside a section's TAGGED DATA BLOCKS,
  * in place. The other half of the fix in `extract.js` — a manifest entry nobody

package/src/uwx/locale-sync.js

@@ -24,7 +24,7 @@ import { proseMirrorToMarkdown, serializeInlineContent } from '@uniweb/content-w
 import { computeHash } from '../i18n/hash.js'
 import { blockElements, elementText, dataBlockNodes } from '../i18n/extract.js'
 import { visitDataBlockStrings } from '../i18n/data-strings.js'
-import { resolveDocForLocale } from '../i18n/merge.js'
+import { resolveDocForLocale, translatedInline, linkLabels } from '../i18n/merge.js'
 import { computeSourceHash } from '../i18n/freeform-manifest.js'
 import { sameMarkdownDocument, canonicalJson } from './same-content.js'
 
@@ -380,7 +380,7 @@ function deriveStructuralMap(sourceDoc, targetDoc, modelFor = () => null) {
       const srcMd = serializeInlineContent(src[i].content || [])
       const tgtMd = serializeInlineContent(tgt[i].content || [])
       if (srcMd === tgtMd) continue // unchanged → untranslated → omit
-      map[key] = tgtMd
+      map[key] = labelsAlone(src[i].content || [], tgt[i].content || [], tgtMd) ?? tgtMd
     }
   } catch {
     // a mark we can't serialize → don't risk a lossy map; store as free-form
@@ -389,6 +389,22 @@ function deriveStructuralMap(sourceDoc, targetDoc, modelFor = () => null) {
   return addDataBlockStrings(map, sourceDoc, targetDoc, modelFor)
 }
 
+// ⭐ A LINK'S LABEL, NOT THE LINK, when only its words were translated. The merge reads a label onto
+// the source's own link (`merge.js::translatedInline`), so it keeps following that link wherever the
+// source moves it, where `[Donar Ahora](/contact)` would keep `/contact`. Several links are a label a
+// line, as a translator writes them. Written only when the merge reads it back to this very element;
+// a link a translator changed — the Spanish button pointed at a Spanish page — is written whole.
+// ⛔ Until 2026-10-08 the element was always written whole: once the merge read a label (2026-10-01),
+// a pull into the copy that pushed rewrote `"Donar Ahora"` as `"[Donar Ahora](/contact)"`, and split a
+// string a page title and a button share into a default and per-place overrides.
+function labelsAlone(source, target, whole) {
+  const labels = linkLabels(source, target)
+  if (!labels) return null
+  const value = labels.map((nodes) => serializeInlineContent(nodes)).join('\n')
+  const back = translatedInline(source, value)
+  return back && serializeInlineContent(back) === whole ? value : null
+}
+
 // ⭐ A TAGGED DATA BLOCK's translated strings, read pairwise — the strings the build translates
 // (`visitDataBlockStrings`: a block's declared shape, else the extractor's heuristic), keyed by their
 // source text as the build keys them. ⭐ Walked by the same model the push translated with — the pairing