uniweb 0.56.8 → 0.56.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "0.56.8",
+  "version": "0.56.10",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -43,14 +43,14 @@
     "tar": "^7.0.0",
     "@uniweb/core": "^0.29.4",
     "@uniweb/kit": "^0.19.3",
-    "@uniweb/schemas": "^0.3.1",
-    "@uniweb/runtime": "^0.26.4",
+    "@uniweb/schemas": "^0.3.3",
+    "@uniweb/content-writer": "^0.3.4",
     "@uniweb/semantic-parser": "^1.4.1",
-    "@uniweb/content-writer": "^0.3.4"
+    "@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-16T23:53:23.238Z",
+  "generatedAt": "2026-09-17T03:53:59.364Z",
   "packages": {
     "@uniweb/api": {
       "version": "0.3.6",
@@ -96,7 +96,7 @@
       "deps": []
     },
     "@uniweb/schemas": {
-      "version": "0.3.1",
+      "version": "0.3.3",
       "path": "framework/schemas",
       "deps": []
     },
@@ -111,12 +111,12 @@
       "deps": []
     },
     "@uniweb/snapshot": {
-      "version": "0.1.0",
+      "version": "0.1.1",
       "path": "framework/snapshot",
       "deps": []
     },
     "@uniweb/templates": {
-      "version": "0.14.6",
+      "version": "0.14.8",
       "path": "framework/templates",
       "deps": []
     },

package/src/utils/scaffold.js

@@ -178,10 +178,22 @@ export async function applyContent(
     '.gitignore'
   ])
 
-  // Config files that should be merged, not overwritten.
-  // Keys listed here are preserved from the scaffolded version.
+  // Config files that should be merged, not overwritten: for each listed
+  // key, when the scaffolded version's value is used.
+  //
+  //   foundation  ALWAYS — the CLI resolved it for this project, and a
+  //               content template cannot know it.
+  //   name        ONLY WHEN THE TEMPLATE SETS NONE. A template's own name is
+  //               the default name of a site made from it — the same thing
+  //               cloning a template in an app gives — so a literal
+  //               `name: Product Launch` survives, and the project name fills
+  //               in for a template with no name, or only the
+  //               `{{projectName}}` placeholder.
   const MERGE_FILES = {
-    'site.yml': ['name', 'foundation']
+    'site.yml': [
+      ['name', 'when-template-has-none'],
+      ['foundation', 'always']
+    ]
   }
 
   await copyContentRecursive(
@@ -267,8 +279,9 @@ async function copyContentRecursive(
       // educational structure of the content template survive) and
       // override only the specific top-level keys listed in
       // preserveKeys with the values from the already-scaffolded base
-      // file (so the user's chosen project name and foundation ref
-      // don't get replaced by whatever the content template hardcoded).
+      // file (so the resolved foundation ref is never replaced by whatever
+      // the content template hardcoded, and a project name fills in for a
+      // template that names nothing).
       //
       // Earlier versions of this code parsed both files through
       // js-yaml, merged the objects, and re-emitted the result via
@@ -283,17 +296,21 @@ async function copyContentRecursive(
         const existing = yaml.load(existingContent) || {}
         let merged = newContent ?? (await fs.readFile(sourcePath, 'utf-8'))
 
-        for (const key of preserveKeys) {
+        for (const [key, when] of preserveKeys) {
           if (existing[key] === undefined) continue
           const baseLine = matchTopLevelLine(existingContent, key)
           if (!baseLine) continue
           // If the new content carries the key, replace its line with
-          // the scaffolded value (preserving the user's project/foundation
-          // choice). Otherwise insert the line — older content templates
-          // (notably `docs/site/site.yml.hbs`) omit `foundation:` entirely,
-          // and dropping it leaves the site without a foundation ref so
-          // the entry's `import '#foundation/styles'` fails at build time.
+          // the scaffolded value — unless the key only fills in, and the
+          // template set a value of its own. Otherwise insert the line —
+          // older content templates (notably `docs/site/site.yml.hbs`) omit
+          // `foundation:` entirely, and dropping it leaves the site without a
+          // foundation ref so the entry's `import '#foundation/styles'` fails
+          // at build time.
           if (matchTopLevelLine(merged, key)) {
+            if (when === 'when-template-has-none' && hasOwnValue(merged, key)) {
+              continue
+            }
             merged = replaceTopLevelLine(merged, key, baseLine)
           } else {
             merged = insertTopLevelLine(merged, baseLine)
@@ -358,6 +375,22 @@ function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
+/**
+ * Whether a content template sets `key` to a value of its own: a non-empty
+ * string that is not an unrendered `{{placeholder}}` (a plain `site.yml`, not
+ * `.hbs`, is copied without rendering). Content that does not parse counts as
+ * setting nothing, so the scaffolded value fills in, as it always did.
+ */
+function hasOwnValue(content, key) {
+  let value
+  try {
+    value = (yaml.load(content) || {})[key]
+  } catch {
+    return false
+  }
+  return typeof value === 'string' && value.trim() !== '' && !value.includes('{{')
+}
+
 /**
  * Find the verbatim text of a single-line top-level YAML entry like
  * `name: foo bar` or `foundation: my-foundation`. Returns the matched

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)
+}