@uniweb/build 1.15.5 → 1.15.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +8 -8
- package/src/site/content-collector.js +31 -22
- package/src/site/file-links.js +91 -26
- package/src/site/index.js +3 -0
- package/src/site/mount-entries.js +46 -0
- package/src/uwx/body-splice.js +85 -0
- package/src/uwx/data-schema.js +4 -0
- package/src/uwx/emit-surface.json +0 -3
- package/src/uwx/index.js +3 -0
- package/src/uwx/page-files.js +255 -0
- package/src/uwx/project-writer.js +19 -3
- package/src/uwx/same-content.js +7 -4
- package/src/uwx/site-dirs.js +50 -6
- package/src/uwx/site-project.js +373 -49
- package/src/uwx/site.js +5 -2
- package/src/uwx/git-authored.js +0 -85
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@uniweb/build",
|
|
3
|
-
"version": "1.15.
|
|
3
|
+
"version": "1.15.6",
|
|
4
4
|
"description": "Build tooling for the Uniweb Component Web Platform",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"exports": {
|
|
@@ -56,12 +56,12 @@
|
|
|
56
56
|
"js-yaml": "^4.3.2",
|
|
57
57
|
"sharp": "^0.35.5",
|
|
58
58
|
"yaml": "^2.5.0",
|
|
59
|
-
"@uniweb/content-reader": "~1.5.
|
|
60
|
-
"@uniweb/projections": "~1.2.11",
|
|
61
|
-
"@uniweb/schemas": "~1.6.7",
|
|
59
|
+
"@uniweb/content-reader": "~1.5.9",
|
|
62
60
|
"@uniweb/semantic-parser": "~1.13.2",
|
|
63
|
-
"@uniweb/
|
|
64
|
-
"@uniweb/
|
|
61
|
+
"@uniweb/schemas": "~1.6.8",
|
|
62
|
+
"@uniweb/projections": "~1.2.11",
|
|
63
|
+
"@uniweb/theming": "~1.2.1",
|
|
64
|
+
"@uniweb/content-writer": "~1.3.1"
|
|
65
65
|
},
|
|
66
66
|
"optionalDependencies": {
|
|
67
67
|
"@uniweb/runtime": "~1.4.5"
|
|
@@ -73,8 +73,8 @@
|
|
|
73
73
|
"@tailwindcss/vite": "^4.0.0",
|
|
74
74
|
"@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
|
|
75
75
|
"vite-plugin-svgr": "^4.0.0",
|
|
76
|
-
"@uniweb/
|
|
77
|
-
"@uniweb/
|
|
76
|
+
"@uniweb/runtime": "~1.4.5",
|
|
77
|
+
"@uniweb/core": "~1.6.4"
|
|
78
78
|
},
|
|
79
79
|
"peerDependenciesMeta": {
|
|
80
80
|
"vite": {
|
|
@@ -26,6 +26,7 @@ import { isSectionKey } from '@uniweb/schemas/section'
|
|
|
26
26
|
import { parseNumericPrefix, compareByNumericPrefix } from '../utils/numeric-prefix.js'
|
|
27
27
|
import { isMarkdownFile, isIgnoredFolder } from '../utils/content-files.js'
|
|
28
28
|
import { readLayoutFolder, DEFAULT_LAYOUT, layoutAreaRoute } from './layout-folder.js'
|
|
29
|
+
import { mountEntriesOf, mountDeclarationsOf } from './mount-entries.js'
|
|
29
30
|
import { basename, join, parse, relative, resolve, sep } from 'node:path'
|
|
30
31
|
import { existsSync, statSync, realpathSync, readdirSync } from 'node:fs'
|
|
31
32
|
import yaml from 'js-yaml'
|
|
@@ -555,7 +556,7 @@ async function readFolderConfig(dirPath, inheritedMode) {
|
|
|
555
556
|
/**
|
|
556
557
|
* A folder's content mode from its two config files — `readFolderConfig`'s rule, as a pure
|
|
557
558
|
* function, so a synchronous reader applies the same one: the pull, which must know which pages
|
|
558
|
-
* a folder's `.md` files are (`uwx/
|
|
559
|
+
* a folder's `.md` files are (`uwx/page-files.js`).
|
|
559
560
|
*
|
|
560
561
|
* - a `folder.yml` with keys → folder mode
|
|
561
562
|
* - else a `page.yml` with keys → page mode
|
|
@@ -604,25 +605,8 @@ function mountHasContent(dirPath) {
|
|
|
604
605
|
})
|
|
605
606
|
}
|
|
606
607
|
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
*
|
|
610
|
-
* Split out from resolveMounts so the dev server can learn which directories a
|
|
611
|
-
* site mounts without re-running resolveMounts' validation — that would repeat
|
|
612
|
-
* its warnings on every startup, and the watcher only needs paths. Every reader —
|
|
613
|
-
* the collector, the watcher, a pull (`uwx/git-authored.js`) and `uniweb status` among
|
|
614
|
-
* them — shares this one definition of what a mount key looks like, so the prefix can never mean
|
|
615
|
-
* one thing to one of them and another to the next.
|
|
616
|
-
*
|
|
617
|
-
* @param {Object} pathsConfig - The paths: object from site.yml
|
|
618
|
-
* @returns {Array<[string, string]>} [routeSegment, relativePath] pairs
|
|
619
|
-
*/
|
|
620
|
-
export function mountEntriesOf(pathsConfig) {
|
|
621
|
-
if (!pathsConfig || typeof pathsConfig !== 'object') return []
|
|
622
|
-
return Object.entries(pathsConfig)
|
|
623
|
-
.filter(([key]) => key.startsWith('pages/'))
|
|
624
|
-
.map(([key, value]) => [key.slice('pages/'.length), value])
|
|
625
|
-
}
|
|
608
|
+
// The one definition of a mount key, a leaf (`./mount-entries.js`), re-exported for its readers here.
|
|
609
|
+
export { mountEntriesOf }
|
|
626
610
|
|
|
627
611
|
/**
|
|
628
612
|
* Extract page mounts from site.yml paths: config.
|
|
@@ -644,14 +628,14 @@ function resolveMounts(pathsConfig, sitePath, pagesPath, { strict = false } = {}
|
|
|
644
628
|
if (!pathsConfig || typeof pathsConfig !== 'object') return null
|
|
645
629
|
|
|
646
630
|
// Extract entries with "pages/" prefix (e.g., "pages/docs": "../../../docs")
|
|
647
|
-
const mountEntries =
|
|
631
|
+
const mountEntries = mountDeclarationsOf(pathsConfig)
|
|
648
632
|
|
|
649
633
|
if (mountEntries.length === 0) return null
|
|
650
634
|
|
|
651
635
|
const resolved = new Map()
|
|
652
636
|
const canonicalPagesPath = existsSync(pagesPath) ? realpathSync(pagesPath) : resolve(pagesPath)
|
|
653
637
|
|
|
654
|
-
for (const
|
|
638
|
+
for (const { segment: routeSegment, path: relativePath, declared } of mountEntries) {
|
|
655
639
|
// Validate route segment (simple name, no slashes, no special chars)
|
|
656
640
|
if (!routeSegment || routeSegment.includes('/') || routeSegment.startsWith('.') || routeSegment.startsWith('_')) {
|
|
657
641
|
throw new Error(
|
|
@@ -660,6 +644,27 @@ function resolveMounts(pathsConfig, sitePath, pagesPath, { strict = false } = {}
|
|
|
660
644
|
)
|
|
661
645
|
}
|
|
662
646
|
|
|
647
|
+
// ⭐ The object form says more of the mount: its `path`, and whether a pull may write into it. Any
|
|
648
|
+
// other key is refused, so a misspelt `writable` is not a mount that reads as read-only.
|
|
649
|
+
if (declared && typeof declared === 'object' && !Array.isArray(declared)) {
|
|
650
|
+
const unknown = Object.keys(declared).filter((k) => k !== 'path' && k !== 'writable')
|
|
651
|
+
if (unknown.length) {
|
|
652
|
+
throw new Error(
|
|
653
|
+
`[content-collector] The mount "pages/${routeSegment}" in site.yml paths has ${unknown.map((k) => `\`${k}\``).join(', ')}, which a mount does not take.\n` +
|
|
654
|
+
` A mount takes \`path:\`, its folder, and \`writable: true\` to let a pull write into it.`
|
|
655
|
+
)
|
|
656
|
+
}
|
|
657
|
+
if (declared.writable !== undefined && typeof declared.writable !== 'boolean') {
|
|
658
|
+
throw new Error(`[content-collector] The mount "pages/${routeSegment}" in site.yml paths says \`writable: ${JSON.stringify(declared.writable)}\`; it takes true or false.`)
|
|
659
|
+
}
|
|
660
|
+
}
|
|
661
|
+
if (typeof relativePath !== 'string' || !relativePath) {
|
|
662
|
+
throw new Error(
|
|
663
|
+
`[content-collector] The mount "pages/${routeSegment}" in site.yml paths names no folder.\n` +
|
|
664
|
+
` Give it one: \`pages/${routeSegment}: ../docs\`, or \`path: ../docs\` in its object.`
|
|
665
|
+
)
|
|
666
|
+
}
|
|
667
|
+
|
|
663
668
|
const absolutePath = resolve(sitePath, relativePath)
|
|
664
669
|
|
|
665
670
|
// Check existence
|
|
@@ -3188,6 +3193,10 @@ export {
|
|
|
3188
3193
|
resolveMounts,
|
|
3189
3194
|
findSectionFile,
|
|
3190
3195
|
processNesting,
|
|
3196
|
+
// The title a folder-mode `.md` page gives — its first heading, else its name — which a pull asks
|
|
3197
|
+
// before it writes one back (`uwx/page-files.js`).
|
|
3198
|
+
extractH1,
|
|
3199
|
+
prettifySlug,
|
|
3191
3200
|
}
|
|
3192
3201
|
|
|
3193
3202
|
export default collectSiteContent
|
package/src/site/file-links.js
CHANGED
|
@@ -14,6 +14,11 @@
|
|
|
14
14
|
* The anchor is translated too. A link written for GitHub names GitHub's anchor for a heading, and a
|
|
15
15
|
* page's heading has its own (`headingId`, `@uniweb/kit`): "it doesn't — matter" is
|
|
16
16
|
* `it-doesnt--matter` on one and `it-doesn-t-matter` on the other.
|
|
17
|
+
*
|
|
18
|
+
* ⭐ AND A PULL PUTS EACH ONE BACK AS THE FILE WROTE IT (`fileLinksIn`). ⛔ Until 2026-11-04 a pull wrote
|
|
19
|
+
* the backend's page link into the file in its place, so every file of a docs folder linking another
|
|
20
|
+
* by file read as changed and came back with `/docs/...` links, which lead nowhere on GitHub: 68 of the
|
|
21
|
+
* framework's own docs, measured that day, the first time a pull wrote into a mounted docs folder.
|
|
17
22
|
*/
|
|
18
23
|
import { realpathSync } from 'node:fs'
|
|
19
24
|
import { dirname, relative, resolve } from 'node:path'
|
|
@@ -30,6 +35,11 @@ export function carrySectionFile(from, to) {
|
|
|
30
35
|
if (FILES.has(from)) FILES.set(to, FILES.get(from))
|
|
31
36
|
}
|
|
32
37
|
|
|
38
|
+
/** The file a section — or a record the push made from one — was read from, or null. */
|
|
39
|
+
export function sectionFileOf(section) {
|
|
40
|
+
return FILES.get(section) ?? null
|
|
41
|
+
}
|
|
42
|
+
|
|
33
43
|
// A relative path to a markdown file: no scheme, no leading `/`, `#` or `?`.
|
|
34
44
|
const FILE_LINK = /^(?![a-z][a-z0-9+.-]*:|[/#?])([^#?]+\.md)(?:#(.*))?$/i
|
|
35
45
|
|
|
@@ -97,6 +107,43 @@ function rewriteDoc(node, rewrite) {
|
|
|
97
107
|
if (Array.isArray(node.content)) for (const child of node.content) rewriteDoc(child, rewrite)
|
|
98
108
|
}
|
|
99
109
|
|
|
110
|
+
/**
|
|
111
|
+
* The pages a site's files became, for the links written as files: each file by its real path, with
|
|
112
|
+
* its page's route, its section's id where the page is of several files, and its headings' anchors.
|
|
113
|
+
*
|
|
114
|
+
* @param {Array<{ route: string, files: Array<{ file: string, id: string|null, content: object }> }>} pages
|
|
115
|
+
* @returns {Map<string, { route: string, section: string|null, anchors: Map<string, string> }>}
|
|
116
|
+
*/
|
|
117
|
+
export function fileLinkTargets(pages) {
|
|
118
|
+
const files = new Map()
|
|
119
|
+
for (const { route, files: held } of pages) {
|
|
120
|
+
for (const { file, id, content } of held) {
|
|
121
|
+
// A page of several files: this file is a section of it, with an anchor of its own.
|
|
122
|
+
files.set(real(file), { route, section: held.length > 1 ? id || null : null, anchors: anchorsOf(content) })
|
|
123
|
+
}
|
|
124
|
+
}
|
|
125
|
+
return files
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
/**
|
|
129
|
+
* The page link a push writes for `href`, written in the file `from` — `{ href, missing }`, `missing`
|
|
130
|
+
* naming what it leads to that is not there (`'file'`, `'anchor'`) — or null for a link no file's.
|
|
131
|
+
*
|
|
132
|
+
* @param {string} href
|
|
133
|
+
* @param {string} from
|
|
134
|
+
* @param {Map} files - `fileLinkTargets`
|
|
135
|
+
* @returns {{ href: string, missing: 'file'|'anchor'|null }|null}
|
|
136
|
+
*/
|
|
137
|
+
export function pageLinkFor(href, from, files) {
|
|
138
|
+
const link = FILE_LINK.exec(href)
|
|
139
|
+
if (!link) return null
|
|
140
|
+
const target = files.get(real(resolve(dirname(from), decode(link[1]))))
|
|
141
|
+
if (!target) return { href, missing: 'file' }
|
|
142
|
+
if (!link[2]) return { href: target.section ? `${target.route}#section-${target.section}` : target.route, missing: null }
|
|
143
|
+
const anchor = target.anchors.get(decode(link[2]))
|
|
144
|
+
return { href: `${target.route}#${anchor ?? link[2]}`, missing: anchor ? null : 'anchor' }
|
|
145
|
+
}
|
|
146
|
+
|
|
100
147
|
/**
|
|
101
148
|
* Rewrites every link written as a file, in the sections of a site's pages. Mutates the sections.
|
|
102
149
|
*
|
|
@@ -105,39 +152,57 @@ function rewriteDoc(node, rewrite) {
|
|
|
105
152
|
* @param {{ siteRoot: string, warn: (message: string) => void }} options
|
|
106
153
|
*/
|
|
107
154
|
export function rewriteFileLinks(pages, { siteRoot, warn }) {
|
|
108
|
-
const files =
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
})
|
|
114
|
-
for (const section of held) {
|
|
115
|
-
files.set(real(FILES.get(section)), {
|
|
116
|
-
route,
|
|
117
|
-
// A page of several files: this file is a section of it, with an anchor of its own.
|
|
118
|
-
section: held.length > 1 ? section.stableId || section.$id || null : null,
|
|
119
|
-
anchors: anchorsOf(section.content),
|
|
155
|
+
const files = fileLinkTargets(
|
|
156
|
+
pages.map(({ route, sections }) => {
|
|
157
|
+
const held = []
|
|
158
|
+
eachSection(sections, (section) => {
|
|
159
|
+
if (FILES.has(section)) held.push({ file: FILES.get(section), id: section.stableId || section.$id || null, content: section.content })
|
|
120
160
|
})
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
161
|
+
return { route, files: held }
|
|
162
|
+
})
|
|
163
|
+
)
|
|
124
164
|
for (const { sections } of pages) {
|
|
125
165
|
eachSection(sections, (section) => {
|
|
126
166
|
const from = FILES.get(section)
|
|
127
167
|
if (!from) return
|
|
128
168
|
rewriteDoc(section.content, (href) => {
|
|
129
|
-
const
|
|
130
|
-
if (
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
warn(`${relative(siteRoot, from)}: the link to ${href} names a file that is no page of this site, so it leads nowhere`)
|
|
134
|
-
return href
|
|
135
|
-
}
|
|
136
|
-
if (!link[2]) return target.section ? `${target.route}#section-${target.section}` : target.route
|
|
137
|
-
const anchor = target.anchors.get(decode(link[2]))
|
|
138
|
-
if (!anchor) warn(`${relative(siteRoot, from)}: the link to ${href}: that page has no such heading`)
|
|
139
|
-
return `${target.route}#${anchor ?? link[2]}`
|
|
169
|
+
const page = pageLinkFor(href, from, files)
|
|
170
|
+
if (page?.missing === 'file') warn(`${relative(siteRoot, from)}: the link to ${href} names a file that is no page of this site, so it leads nowhere`)
|
|
171
|
+
if (page?.missing === 'anchor') warn(`${relative(siteRoot, from)}: the link to ${href}: that page has no such heading`)
|
|
172
|
+
return page ? page.href : href
|
|
140
173
|
})
|
|
141
174
|
})
|
|
142
175
|
}
|
|
143
176
|
}
|
|
177
|
+
|
|
178
|
+
/**
|
|
179
|
+
* ⭐ A FILE'S LINKS AS A PUSH READS THEM, AND BACK, for a pull writing the backend's document into the
|
|
180
|
+
* file a section was read from (`uwx/project-writer.js`). `resolve` gives a node of the file the page
|
|
181
|
+
* links a push sends for its file links, so it compares with the backend's; `restore` writes each page
|
|
182
|
+
* link the file wrote as a file back in the file's own spelling — `../guide/deploying.md`, which works
|
|
183
|
+
* on GitHub and in an editor, never `/docs/guide/deploying`. A link the app added stays the app's.
|
|
184
|
+
*
|
|
185
|
+
* @param {string} from - the file
|
|
186
|
+
* @param {Map} files - `fileLinkTargets`
|
|
187
|
+
* @param {object|null} authored - the file's own document, as it reads
|
|
188
|
+
* @returns {{ resolve: (node: object) => object, restore: (node: object) => object }}
|
|
189
|
+
*/
|
|
190
|
+
export function fileLinksIn(from, files, authored) {
|
|
191
|
+
const back = new Map()
|
|
192
|
+
if (authored) {
|
|
193
|
+
rewriteDoc(structuredClone(authored), (href) => {
|
|
194
|
+
const page = pageLinkFor(href, from, files)
|
|
195
|
+
if (page && page.href !== href && !back.has(page.href)) back.set(page.href, href)
|
|
196
|
+
return href
|
|
197
|
+
})
|
|
198
|
+
}
|
|
199
|
+
const mapped = (node, rewrite) => {
|
|
200
|
+
const copy = structuredClone(node)
|
|
201
|
+
rewriteDoc(copy, rewrite)
|
|
202
|
+
return copy
|
|
203
|
+
}
|
|
204
|
+
return {
|
|
205
|
+
resolve: (node) => mapped(node, (href) => pageLinkFor(href, from, files)?.href ?? href),
|
|
206
|
+
restore: (node) => (back.size ? mapped(node, (href) => back.get(href) ?? href) : node),
|
|
207
|
+
}
|
|
208
|
+
}
|
package/src/site/index.js
CHANGED
|
@@ -15,6 +15,9 @@ export { DEV_PORT_ENV, DEV_RECORD_ENV, runningDevServer, stopDevServer } from '.
|
|
|
15
15
|
// Where a statically built site lives, as its deploy target or author states it (`./site-address.js`).
|
|
16
16
|
export { ORIGIN_ENV, refuseUnreadableAddress } from './site-address.js'
|
|
17
17
|
export { collectSiteContent, mountEntriesOf } from './content-collector.js'
|
|
18
|
+
// Each mount with what its declaration says — whether a pull may write into it among it — for the
|
|
19
|
+
// CLI, which decides which ones a pull can (`./mount-entries.js`).
|
|
20
|
+
export { mountDeclarationsOf } from './mount-entries.js'
|
|
18
21
|
export { addVersion } from './add-version.js'
|
|
19
22
|
// The favicon a build links when site.yml names none, for `uniweb doctor` (`./favicon.js`).
|
|
20
23
|
export { findPublicFavicon } from './favicon.js'
|
|
@@ -0,0 +1,46 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The `pages/<segment>` keys in a site.yml `paths:` group, unvalidated.
|
|
3
|
+
*
|
|
4
|
+
* Split out from resolveMounts so the dev server can learn which directories a
|
|
5
|
+
* site mounts without re-running resolveMounts' validation — that would repeat
|
|
6
|
+
* its warnings on every startup, and the watcher only needs paths. Every reader —
|
|
7
|
+
* the collector, the watcher, a pull (`uwx/page-files.js`), the roots a push sends
|
|
8
|
+
* and a pull merges (`uwx/site-dirs.js`) and `uniweb status` among them — shares this
|
|
9
|
+
* one definition of what a mount key looks like, so the prefix can never mean one
|
|
10
|
+
* thing to one of them and another to the next.
|
|
11
|
+
*
|
|
12
|
+
* A mount is a folder, `pages/docs: ../docs`, or an object saying more of it,
|
|
13
|
+
* `pages/docs: { path: ../docs, writable: true }`: each reader here is handed the
|
|
14
|
+
* folder, and `mountDeclarationsOf` the rest (`resolveMounts` refuses a malformed one).
|
|
15
|
+
*
|
|
16
|
+
* A leaf, with no imports, so a module that must stay light can ask it.
|
|
17
|
+
*
|
|
18
|
+
* @param {Object} pathsConfig - The paths: object from site.yml
|
|
19
|
+
* @returns {Array<[string, string]>} [routeSegment, relativePath] pairs
|
|
20
|
+
*/
|
|
21
|
+
export function mountEntriesOf(pathsConfig) {
|
|
22
|
+
return mountDeclarationsOf(pathsConfig).map(({ segment, path }) => [segment, path])
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/**
|
|
26
|
+
* Each mount with what its declaration says: its route `segment`, its folder's `path`, and whether
|
|
27
|
+
* a pull may write into it (`writable`) — ⭐ a pull writes a mounted folder only where the site says
|
|
28
|
+
* so; the string form only reads.
|
|
29
|
+
*
|
|
30
|
+
* @param {Object} pathsConfig - The paths: object from site.yml
|
|
31
|
+
* @returns {Array<{ segment: string, path: string, writable: boolean, declared: unknown }>}
|
|
32
|
+
*/
|
|
33
|
+
export function mountDeclarationsOf(pathsConfig) {
|
|
34
|
+
if (!pathsConfig || typeof pathsConfig !== 'object') return []
|
|
35
|
+
return Object.entries(pathsConfig)
|
|
36
|
+
.filter(([key]) => key.startsWith('pages/'))
|
|
37
|
+
.map(([key, value]) => {
|
|
38
|
+
const object = value !== null && typeof value === 'object' && !Array.isArray(value)
|
|
39
|
+
return {
|
|
40
|
+
segment: key.slice('pages/'.length),
|
|
41
|
+
path: object ? value.path : value,
|
|
42
|
+
writable: object && value.writable === true,
|
|
43
|
+
declared: value,
|
|
44
|
+
}
|
|
45
|
+
})
|
|
46
|
+
}
|
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
// ⭐ A PULL WRITES THE CHANGE, NOT A NEW RENDERING OF THE FILE.
|
|
2
|
+
// A changed body keeps the author's text for every top-level block the backend's document still holds,
|
|
3
|
+
// and takes the writer's form only for the blocks it changed, added or moved; a removed one goes.
|
|
4
|
+
//
|
|
5
|
+
// ⛔ Until 2026-11-04 a changed body was re-serialized whole. Measured that day over the 133 pages of
|
|
6
|
+
// three mounted docs folders: a one-word edit rewrote a median of 12 lines — every hard-wrapped
|
|
7
|
+
// paragraph joined, every table rule rewritten — in 115 of them.
|
|
8
|
+
//
|
|
9
|
+
// The blocks are the reader's (`markdownBlocks`, `@uniweb/content-reader`), so a block is what the
|
|
10
|
+
// author's text reads as, and a body the reader cannot split so, or whose splice does not read back to
|
|
11
|
+
// the document, is written whole as before.
|
|
12
|
+
//
|
|
13
|
+
// `links` reads a block as the push reads it, and writes a new one as the file writes its links
|
|
14
|
+
// (`site/file-links.js::fileLinksIn`): a block linking another file by its file is the block the
|
|
15
|
+
// backend holds with a page link, and keeps the author's link.
|
|
16
|
+
|
|
17
|
+
import { markdownBlocks } from '@uniweb/content-reader'
|
|
18
|
+
import { proseMirrorToMarkdown } from '@uniweb/content-writer'
|
|
19
|
+
import { canonicalJson, sameMarkdownDocument, withoutDefaults } from './same-content.js'
|
|
20
|
+
|
|
21
|
+
const keyOf = (node) => canonicalJson(withoutDefaults(node))
|
|
22
|
+
|
|
23
|
+
// The longest run of keys the two lists share, in order: each pair `[i, j]`, `a[i]` equal to `b[j]`.
|
|
24
|
+
function commonPairs(a, b) {
|
|
25
|
+
const n = a.length
|
|
26
|
+
const m = b.length
|
|
27
|
+
const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1))
|
|
28
|
+
for (let i = n - 1; i >= 0; i--) {
|
|
29
|
+
for (let j = m - 1; j >= 0; j--) dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1])
|
|
30
|
+
}
|
|
31
|
+
const pairs = []
|
|
32
|
+
for (let i = 0, j = 0; i < n && j < m; ) {
|
|
33
|
+
if (a[i] === b[j]) pairs.push([i++, j++])
|
|
34
|
+
else if (dp[i + 1][j] >= dp[i][j + 1]) i++
|
|
35
|
+
else j++
|
|
36
|
+
}
|
|
37
|
+
return pairs
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* The author's body with the backend's document written into it, block by block — or null when it
|
|
42
|
+
* cannot be said so, and the caller writes the document whole.
|
|
43
|
+
*
|
|
44
|
+
* @param {string} authored - the body as the file holds it, frontmatter apart
|
|
45
|
+
* @param {object} doc - the backend's ProseMirror document for it
|
|
46
|
+
* @param {{ links?: { resolve: Function, restore: Function }|null }} [opts]
|
|
47
|
+
* @returns {string|null} the new body, with no trailing whitespace
|
|
48
|
+
*/
|
|
49
|
+
export function spliceBody(authored, doc, { links = null } = {}) {
|
|
50
|
+
const split = markdownBlocks(authored)
|
|
51
|
+
if (!split || !Array.isArray(doc?.content)) return null
|
|
52
|
+
// Each block that reads to one node is an item; one that reads to none (a link reference) rides
|
|
53
|
+
// with the item before it, kept where it was. A block of several nodes leaves nothing to align.
|
|
54
|
+
const items = []
|
|
55
|
+
let head = split.head
|
|
56
|
+
for (const block of split.blocks) {
|
|
57
|
+
if (block.nodes.length > 1) return null
|
|
58
|
+
if (block.nodes.length === 0) {
|
|
59
|
+
if (items.length) items[items.length - 1].after += block.text + block.after
|
|
60
|
+
else head += block.text + block.after
|
|
61
|
+
continue
|
|
62
|
+
}
|
|
63
|
+
items.push({ text: block.text, after: block.after, key: keyOf(links ? links.resolve(block.nodes[0]) : block.nodes[0]) })
|
|
64
|
+
}
|
|
65
|
+
const nodes = doc.content
|
|
66
|
+
const kept = new Map(commonPairs(items.map((i) => i.key), nodes.map(keyOf)).map(([i, j]) => [j, i]))
|
|
67
|
+
// The new body's pieces in the document's order: an item the change left as the author wrote it, or a
|
|
68
|
+
// run of nodes the writer writes.
|
|
69
|
+
const pieces = []
|
|
70
|
+
for (let j = 0; j < nodes.length; j++) {
|
|
71
|
+
if (kept.has(j)) pieces.push({ item: kept.get(j) })
|
|
72
|
+
else if (pieces.length && pieces[pieces.length - 1].nodes) pieces[pieces.length - 1].nodes.push(nodes[j])
|
|
73
|
+
else pieces.push({ nodes: [nodes[j]] })
|
|
74
|
+
}
|
|
75
|
+
let out = pieces[0]?.item === 0 ? head : ''
|
|
76
|
+
pieces.forEach((piece, k) => {
|
|
77
|
+
const written = links ? piece.nodes?.map((node) => links.restore(node)) : piece.nodes
|
|
78
|
+
out += written ? proseMirrorToMarkdown({ type: 'doc', content: written }).replace(/\s+$/, '') : items[piece.item].text
|
|
79
|
+
const next = pieces[k + 1]
|
|
80
|
+
// Two of the author's blocks still side by side keep what stood between them.
|
|
81
|
+
if (next) out += piece.item !== undefined && next.item === piece.item + 1 ? items[piece.item].after : '\n\n'
|
|
82
|
+
})
|
|
83
|
+
const body = out.replace(/^\n+/, '').replace(/\s+$/, '')
|
|
84
|
+
return sameMarkdownDocument(body, doc, { resolve: links?.resolve }) ? body : null
|
|
85
|
+
}
|
package/src/uwx/data-schema.js
CHANGED
|
@@ -547,6 +547,10 @@ function lowerLeaf(field, resolve, optResolve, { multiple = false, path = '' } =
|
|
|
547
547
|
if (field.label) out.label = field.label
|
|
548
548
|
if (field.description) out.description = field.description
|
|
549
549
|
if (field.required) out.required = true
|
|
550
|
+
// A value a site's visitor may fill, on any leaf kind, as authored [backend, 2026-11-04]. A type
|
|
551
|
+
// with one takes visitors' submissions; `@uniweb/schemas` refuses it where a registry would, and
|
|
552
|
+
// drops `false`, so only `true` is sent.
|
|
553
|
+
if (field.visitor_fills === true) out.visitor_fills = true
|
|
550
554
|
// A field's rules, as written — `max_length`, `min`, `max`, `mime_types`, `max_size`,
|
|
551
555
|
// `pattern` (`FIELD_RULES`): a registry keeps each as the field's own key and checks it on
|
|
552
556
|
// every write. ⛔ Until 2026-10-15 the normalizer dropped them before this saw them.
|
package/src/uwx/index.js
CHANGED
|
@@ -89,6 +89,9 @@ export { dataBlockModels } from '../i18n/data-models.js'
|
|
|
89
89
|
// The type a section that names none renders with — a push fills it in, and a pull, handed it up
|
|
90
90
|
// front like the scope above, leaves it out of the section's file.
|
|
91
91
|
export { siteDefaultSectionType } from '../site/queries-config.js'
|
|
92
|
+
// Every place a push reads the site's content from, mounts included — the one answer the CLI's
|
|
93
|
+
// committed-content check, a pull's merge and `uniweb status` read (`site-dirs.js`).
|
|
94
|
+
export { siteContentRoots } from './site-dirs.js'
|
|
92
95
|
export {
|
|
93
96
|
siteInfoToConfig,
|
|
94
97
|
sectionRecordToFile,
|