uniweb 0.56.9 → 0.56.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.56.9",
+  "version": "0.56.10",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -42,15 +42,15 @@
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
     "@uniweb/core": "^0.29.4",
-    "@uniweb/runtime": "^0.26.4",
-    "@uniweb/semantic-parser": "^1.4.1",
-    "@uniweb/schemas": "^0.3.2",
+    "@uniweb/kit": "^0.19.3",
+    "@uniweb/schemas": "^0.3.3",
     "@uniweb/content-writer": "^0.3.4",
-    "@uniweb/kit": "^0.19.3"
+    "@uniweb/semantic-parser": "^1.4.1",
+    "@uniweb/runtime": "^0.26.4"
   },
   "peerDependencies": {
-    "@uniweb/build": "^0.52.6",
     "@uniweb/content-reader": "^1.2.5",
+    "@uniweb/build": "^0.52.6",
     "@uniweb/semantic-parser": "^1.4.1"
   },
   "peerDependenciesMeta": {

package/src/commands/rename.js

@@ -60,6 +60,7 @@ import { writeJsonPreservingStyleAsync } from '../utils/json-file.js'
 import { getExistingPackageNames, validatePackageName } from '../utils/names.js'
 import { detectPackageManager, installCmd } from '../utils/pm.js'
 import { getCliPrefix } from '../utils/interactive.js'
+import { replaceInTopLevelList, setTopLevelScalar } from '../utils/yaml-edit.js'
 
 const colors = {
   reset: '\x1b[0m',
@@ -208,6 +209,24 @@ async function rewritePackageJsonName(pkgPath, newName) {
   await writeJsonPreservingStyleAsync(pkgPath, pkg, src)
 }
 
+/**
+ * Stop, before any file moves, when a site's `site.yml` names the package in a
+ * form the in-place edit cannot reach. The alternative is rewriting the whole
+ * file, which loses the author's comments and formatting — so we refuse and say
+ * how to write it instead.
+ */
+function refuseUneditableSiteYml(sitePaths, key, hint) {
+  if (sitePaths.length === 0) return
+  for (const path of sitePaths) {
+    error(
+      `Cannot rename: ${colors.bright}${path}/site.yml${colors.reset} writes \`${key}:\` in a form this command cannot edit without rewriting the file.`
+    )
+  }
+  log(`Nothing was changed. ${hint}`)
+  log('Then run the rename again.')
+  process.exit(1)
+}
+
 // ─── Foundation rename ───────────────────────────────────────────
 
 async function renameFoundation(rootDir, oldName, newName, prefix) {
@@ -262,7 +281,7 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
   for (const site of sites) {
     const sitePkgPath = join(rootDir, site.path, 'package.json')
     const siteYmlPath = join(rootDir, site.path, 'site.yml')
-    let pkg, pkgSrc, ymlData
+    let pkg, pkgSrc, ymlText, ymlData
     try {
       pkgSrc = await readFile(sitePkgPath, 'utf-8')
       pkg = JSON.parse(pkgSrc)
@@ -271,7 +290,8 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
       pkgSrc = null
     }
     try {
-      ymlData = yaml.load(await readFile(siteYmlPath, 'utf-8')) || {}
+      ymlText = await readFile(siteYmlPath, 'utf-8')
+      ymlData = yaml.load(ymlText) || {}
     } catch {
       ymlData = null
     }
@@ -285,12 +305,19 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
         pkgSrc,
         sitePkgPath,
         siteYmlPath,
-        ymlData,
+        // Edited in place — see utils/yaml-edit.js — and computed HERE, before
+        // anything moves, so a file it cannot edit stops the rename cleanly.
+        newYmlText: ymlMatches ? setTopLevelScalar(ymlText, 'foundation', newName) : null,
         hasDep,
         ymlMatches
       })
     }
   }
+  refuseUneditableSiteYml(
+    affectedSites.filter((s) => s.ymlMatches && s.newYmlText === null).map((s) => s.path),
+    'foundation',
+    `Write it on one line: \`foundation: ${oldName}\`.`
+  )
 
   // ─── Print plan, then execute ────────────────────────────────
 
@@ -333,11 +360,7 @@ async function renameFoundation(rootDir, oldName, newName, prefix) {
       await writeJsonPreservingStyleAsync(s.sitePkgPath, s.pkg, s.pkgSrc)
     }
     if (s.ymlMatches) {
-      const newYmlData = { ...s.ymlData, foundation: newName }
-      await writeFile(
-        s.siteYmlPath,
-        yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" })
-      )
+      await writeFile(s.siteYmlPath, s.newYmlText)
     }
   }
 
@@ -485,9 +508,10 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
   const affectedSites = []
   for (const site of sites) {
     const siteYmlPath = join(rootDir, site.path, 'site.yml')
-    let ymlData
+    let ymlText, ymlData
     try {
-      ymlData = yaml.load(await readFile(siteYmlPath, 'utf-8')) || {}
+      ymlText = await readFile(siteYmlPath, 'utf-8')
+      ymlData = yaml.load(ymlText) || {}
     } catch {
       continue
     }
@@ -496,9 +520,23 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
       (e) => typeof e === 'string' && e.startsWith(oldUrlPrefix)
     )
     if (hits.length > 0) {
-      affectedSites.push({ site, ymlData, siteYmlPath, hits })
+      const replacements = new Map(
+        hits.map((e) => [e, newUrlPrefix + e.slice(oldUrlPrefix.length)])
+      )
+      affectedSites.push({
+        site,
+        siteYmlPath,
+        hits,
+        // Edited in place, and computed before anything moves — as for foundations.
+        newYmlText: replaceInTopLevelList(ymlText, 'extensions', replacements)
+      })
     }
   }
+  refuseUneditableSiteYml(
+    affectedSites.filter((a) => a.newYmlText === null).map((a) => a.site.path),
+    'extensions',
+    `Write each entry on a line of its own, e.g. \`- ${oldUrlPrefix}dist/entry.js\`.`
+  )
 
   log('')
   log(
@@ -531,16 +569,7 @@ async function renameExtension(rootDir, oldName, newName, prefix) {
   await rewritePackageJsonName(join(newExtDir, 'package.json'), newName)
 
   for (const a of affectedSites) {
-    const newExts = (a.ymlData.extensions || []).map((e) =>
-      typeof e === 'string' && e.startsWith(oldUrlPrefix)
-        ? newUrlPrefix + e.slice(oldUrlPrefix.length)
-        : e
-    )
-    const newYmlData = { ...a.ymlData, extensions: newExts }
-    await writeFile(
-      a.siteYmlPath,
-      yaml.dump(newYmlData, { flowLevel: -1, quotingType: "'" })
-    )
+    await writeFile(a.siteYmlPath, a.newYmlText)
   }
 
   if (folderWillRename) {

package/src/framework-index.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-09-17T03:24:18.741Z",
+  "generatedAt": "2026-09-17T03:53:59.364Z",
   "packages": {
     "@uniweb/api": {
       "version": "0.3.6",
@@ -96,7 +96,7 @@
       "deps": []
     },
     "@uniweb/schemas": {
-      "version": "0.3.2",
+      "version": "0.3.3",
       "path": "framework/schemas",
       "deps": []
     },
@@ -116,7 +116,7 @@
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.14.7",
+      "version": "0.14.8",
       "path": "framework/templates",
       "deps": []
     },

package/src/utils/yaml-edit.js

@@ -0,0 +1,115 @@
+/**
+ * In-place edits to a YAML file a person wrote (`site.yml`), for a command that
+ * must change one value and leave everything else as it was: comments, key
+ * order, blank lines, quoting, a flow list written on one line.
+ *
+ * ⛔ Never load a hand-written file and dump it back. js-yaml's `dump` drops every
+ * comment and re-flows lists and long strings — `scaffold.js` records what that
+ * did to the templates whose comments are the point of them.
+ *
+ * ⭐ Every edit is VERIFIED: the edited text must parse to exactly the old data
+ * with that one value changed. A value written in a form the line-level edit
+ * cannot reach (a block scalar, an entry split across lines) returns null
+ * rather than a guess, so the caller can refuse before it changes anything.
+ */
+
+import { isDeepStrictEqual } from 'node:util'
+import yaml from 'js-yaml'
+
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+/** A scalar as written after `key: `, quoted only when YAML needs it (`@scope/name` does). */
+const scalar = (value) => yaml.dump(value, { lineWidth: -1 }).trim()
+
+/**
+ * Where a trailing ` # comment` begins in the text after `key:`, outside quotes,
+ * including the whitespace before it. -1 when the line has none.
+ */
+function commentStart(rest) {
+  let quote = null
+  for (let i = 0; i < rest.length; i++) {
+    const ch = rest[i]
+    if (quote) {
+      if (ch === quote) quote = null
+    } else if (ch === '"' || ch === "'") {
+      quote = ch
+    } else if (ch === '#' && i > 0 && /\s/.test(rest[i - 1])) {
+      let start = i
+      while (start > 0 && /\s/.test(rest[start - 1])) start--
+      return start
+    }
+  }
+  return -1
+}
+
+/** The edited text when it parses to `expected`, else null. */
+function verified(after, expected) {
+  try {
+    return isDeepStrictEqual(yaml.load(after) ?? {}, expected) ? after : null
+  } catch {
+    return null
+  }
+}
+
+function load(text) {
+  try {
+    const data = yaml.load(text) ?? {}
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Set a top-level, one-line scalar `key` to `value`, keeping the line's inline
+ * comment and every other line as it was.
+ *
+ * @param {string} text - the file's contents
+ * @param {string} key - a top-level key, e.g. `foundation`
+ * @param {string} value
+ * @returns {string|null} the new contents, or null when the edit cannot be made in place
+ */
+export function setTopLevelScalar(text, key, value) {
+  const data = load(text)
+  if (!data) return null
+  const match = new RegExp(`^${escapeRegex(key)}:([^\\n]*)$`, 'm').exec(text)
+  if (!match) return null
+  const at = commentStart(match[1])
+  const comment = at === -1 ? '' : match[1].slice(at)
+  const line = `${key}: ${scalar(value)}${comment}`
+  const after = text.slice(0, match.index) + line + text.slice(match.index + match[0].length)
+  return verified(after, { ...data, [key]: value })
+}
+
+/**
+ * Replace entries of a top-level list `key` — each `from` value becomes its `to`
+ * — wherever an entry is written on a line of its own or inside a one-line flow
+ * list, plain or quoted. A value that only CONTAINS `from` is left alone, and so
+ * is a comment line.
+ *
+ * @param {string} text - the file's contents
+ * @param {string} key - a top-level list key, e.g. `extensions`
+ * @param {Map<string, string>} replacements - old entry → new entry
+ * @returns {string|null} the new contents, or null when the edit cannot be made in place
+ */
+export function replaceInTopLevelList(text, key, replacements) {
+  const data = load(text)
+  if (!data || !Array.isArray(data[key])) return null
+  const expected = { ...data, [key]: data[key].map((v) => (replacements.has(v) ? replacements.get(v) : v)) }
+
+  const after = text
+    .split('\n')
+    .map((line) => {
+      if (/^\s*#/.test(line)) return line
+      for (const [from, to] of replacements) {
+        const f = escapeRegex(from)
+        line = line
+          .replace(new RegExp(`'${f}'`, 'g'), () => `'${to.replace(/'/g, "''")}'`)
+          .replace(new RegExp(`"${f}"`, 'g'), () => JSON.stringify(to))
+          .replace(new RegExp(`(^|[\\s\\[,])${f}(?=$|[\\s,\\]])`, 'g'), (_, lead) => lead + to)
+      }
+      return line
+    })
+    .join('\n')
+  return verified(after, expected)
+}