@exodus/stasis-core 1.0.0-beta.9 → 1.0.0-rc.1
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/bin/stasis-core.js +9 -98
- package/package.json +6 -2
- package/src/add.js +161 -157
- package/src/artifact-util.js +319 -221
- package/src/brotli.js +21 -6
- package/src/bundle-util.js +142 -100
- package/src/bundle.js +89 -128
- package/src/cli.js +123 -0
- package/src/config.js +74 -87
- package/src/extract.js +140 -67
- package/src/fs.js +57 -106
- package/src/hooks.js +126 -238
- package/src/host.js +9 -1
- package/src/loader.js +1 -1
- package/src/lockfile.js +58 -74
- package/src/policy.js +222 -0
- package/src/prune.js +60 -114
- package/src/shard.js +10 -25
- package/src/state-util.js +24 -9
- package/src/state.js +722 -865
- package/src/util.js +123 -172
package/src/brotli.js
CHANGED
|
@@ -1,14 +1,13 @@
|
|
|
1
|
-
import { constants as zlibConstants } from 'node:zlib'
|
|
1
|
+
import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from 'node:zlib'
|
|
2
2
|
|
|
3
|
+
import { Bundle } from './bundle.js'
|
|
3
4
|
import { assert, isBrotliQuality, parseBrotliQuality } from './util.js'
|
|
4
5
|
|
|
5
|
-
// Default brotli quality;
|
|
6
|
-
export const DEFAULT_BROTLI_QUALITY =
|
|
6
|
+
// Default brotli quality; the top levels (10, 11) cost far more time for a marginal size gain.
|
|
7
|
+
export const DEFAULT_BROTLI_QUALITY = 6
|
|
7
8
|
|
|
8
9
|
export function brotliOptions(quality) {
|
|
9
|
-
|
|
10
|
-
assert(isBrotliQuality(quality), `brotli quality must be an integer 0..11, got ${quality}`)
|
|
11
|
-
}
|
|
10
|
+
assert(quality === undefined || isBrotliQuality(quality), `brotli quality must be an integer 0..11, got ${quality}`)
|
|
12
11
|
const raw = process.env.EXODUS_STASIS_BROTLI_QUALITY
|
|
13
12
|
if (raw) {
|
|
14
13
|
const n = parseBrotliQuality('EXODUS_STASIS_BROTLI_QUALITY', raw)
|
|
@@ -18,3 +17,19 @@ export function brotliOptions(quality) {
|
|
|
18
17
|
}
|
|
19
18
|
return { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: quality ?? DEFAULT_BROTLI_QUALITY } }
|
|
20
19
|
}
|
|
20
|
+
|
|
21
|
+
// zlib's brotli decoder ignores bytes after the stream, where DecompressionStream refuses them with this error.
|
|
22
|
+
export const trailingJunkError = () => Object.assign(
|
|
23
|
+
new TypeError('Trailing junk found after the end of the compressed stream'),
|
|
24
|
+
{ code: 'ERR_TRAILING_JUNK_AFTER_STREAM_END' })
|
|
25
|
+
|
|
26
|
+
// The engine's bytesWritten counts the input it consumed, which stops where the stream does.
|
|
27
|
+
export function brotliDecompressStrict(bytes) {
|
|
28
|
+
const { buffer, engine } = brotliDecompressSync(bytes, { info: true })
|
|
29
|
+
if (engine.bytesWritten !== Buffer.byteLength(bytes)) throw trailingJunkError()
|
|
30
|
+
return buffer
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
export const compressBundleText = (text, quality) => brotliCompressSync(text, brotliOptions(quality))
|
|
34
|
+
export const compressBundle = (bundle, quality) => brotliCompressSync(bundle.serializedBytes(), brotliOptions(quality))
|
|
35
|
+
export const parseBundleBytes = (bytes) => Bundle.parse(brotliDecompressStrict(bytes).toString('utf8'))
|
package/src/bundle-util.js
CHANGED
|
@@ -2,85 +2,152 @@ import { isUtf8 } from 'node:buffer'
|
|
|
2
2
|
import { dirname, join, posix, relative, resolve } from 'node:path'
|
|
3
3
|
|
|
4
4
|
import { isValidRepoField } from './bundle.js'
|
|
5
|
-
import { posixPathEscapes } from './artifact-util.js'
|
|
5
|
+
import { isPackageString, isSubpackage, posixPathEscapes } from './artifact-util.js'
|
|
6
6
|
import { diskHost } from './host.js'
|
|
7
|
-
import { assertRealPathWithinBase, hasNodeModulesSegment, relativeEscapes, toPosix } from './util.js'
|
|
7
|
+
import { assertRealPathWithinBase, hasNodeModulesSegment, memoized, relativeEscapes, splitNodeModulesPath, toPosix } from './util.js'
|
|
8
8
|
|
|
9
|
-
//
|
|
9
|
+
// As Node reads a package.json: UTF-8, past a byte order mark.
|
|
10
10
|
const utf8 = new TextDecoder()
|
|
11
11
|
export const packageJSONText = (bytes) => utf8.decode(bytes)
|
|
12
12
|
|
|
13
|
-
|
|
13
|
+
// `kept(path, read)` caches by the package.json's path (a scan reads the same one for each file under it).
|
|
14
|
+
export function packageType(file, host = diskHost, kept = (path, read) => read()) {
|
|
14
15
|
const pkg = host.findPackageJSON(file)
|
|
15
16
|
if (!pkg) return null
|
|
16
|
-
|
|
17
|
-
const type =
|
|
17
|
+
return kept(pkg, () => {
|
|
18
|
+
const type = readJson(pkg, host)?.type
|
|
18
19
|
return type === 'module' || type === 'commonjs' ? type : null
|
|
19
|
-
}
|
|
20
|
-
|
|
20
|
+
})
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
// By host package name, so any layout or alias matches. Add only a confirmed upstream layout, with its reason.
|
|
24
|
+
const VENDOR_DIRS = {
|
|
25
|
+
__proto__: null,
|
|
26
|
+
next: ['dist/compiled'], // the dependencies Next.js compiles in, ~140, each with a trimmed package.json
|
|
27
|
+
}
|
|
28
|
+
const VENDOR_DIR_LIST = Object.values(VENDOR_DIRS).flat()
|
|
29
|
+
|
|
30
|
+
const inAnyVendorDir = (rel) => VENDOR_DIR_LIST.some((dir) => rel.startsWith(`${dir}/`))
|
|
31
|
+
|
|
32
|
+
export const vendorDirOf = (name, rel) => VENDOR_DIRS[name]?.find((dir) => rel.startsWith(`${dir}/`))
|
|
33
|
+
|
|
34
|
+
const manifestIdentity = (pkg) => ({ name: pkg.name, ...(isPackageString(pkg.version) ? { version: pkg.version } : {}) })
|
|
35
|
+
|
|
36
|
+
// `below`: whether any package.json under `vendorDir` covers the file at all.
|
|
37
|
+
export function vendoredPackageOf(rel, vendorDir, read) {
|
|
38
|
+
let below = false
|
|
39
|
+
for (let dir = posix.dirname(rel); dir.startsWith(`${vendorDir}/`); dir = posix.dirname(dir)) {
|
|
40
|
+
const pkg = read(dir)
|
|
41
|
+
if (pkg === null) continue
|
|
42
|
+
below = true
|
|
43
|
+
if (pkg?.name === undefined) continue // a `{"type":"module"}` marker inside the vendored package
|
|
44
|
+
return isPackageString(pkg.name) ? { below, vendored: { dir, ...manifestIdentity(pkg) } } : { below }
|
|
45
|
+
}
|
|
46
|
+
return { below }
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
export function namedManifestOf(rel, read) {
|
|
50
|
+
for (let dir = posix.dirname(rel); dir !== '.'; dir = posix.dirname(dir)) {
|
|
51
|
+
const pkg = read(dir)
|
|
52
|
+
if (pkg?.name !== undefined) return { dir, pkg }
|
|
21
53
|
}
|
|
54
|
+
return undefined
|
|
22
55
|
}
|
|
23
56
|
|
|
24
|
-
//
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
57
|
+
// A nearer package.json than the package's own, which Node takes the file's `type` from and Metro its fields.
|
|
58
|
+
export function scopeManifestOf(rel, pkgDir, exists) {
|
|
59
|
+
if (pkgDir !== '.' && !rel.startsWith(`${pkgDir}/`)) return undefined
|
|
60
|
+
for (let dir = posix.dirname(rel); dir !== pkgDir && dir !== '.'; dir = posix.dirname(dir)) {
|
|
61
|
+
if (exists(`${dir}/package.json`)) return `${dir}/package.json`
|
|
62
|
+
}
|
|
63
|
+
return undefined
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
// In node_modules a bucket's package.json needs name and version; outside, a name alone, as State#locateModule.
|
|
67
|
+
// A malformed one is walked past, or with `strict` throws (its files would otherwise land in the parent's).
|
|
30
68
|
export function findPackageMetadata(baseDir, fileRelPath, { strict = false, check, host = diskHost } = {}) {
|
|
69
|
+
const options = { strict, check, host }
|
|
70
|
+
const read = (rel) => readPackageJson(baseDir, rel, options)
|
|
71
|
+
const nm = splitNodeModulesPath(toPosix(fileRelPath))
|
|
72
|
+
// A file in a vendored package is its host's, as State#locateModule has it.
|
|
73
|
+
if (nm !== null && inAnyVendorDir(nm.rel)) {
|
|
74
|
+
const pkg = read(`${nm.dir}/package.json`)
|
|
75
|
+
const vendorDir = pkg?.name && pkg.version ? vendorDirOf(pkg.name, nm.rel) : undefined
|
|
76
|
+
const { below, vendored } = vendorDir === undefined ? {} : vendoredPackageOf(nm.rel, vendorDir, (sub) => read(`${nm.dir}/${sub}/package.json`))
|
|
77
|
+
if (below) {
|
|
78
|
+
const repo = packageRepo(pkg)
|
|
79
|
+
const { dir: sub, ...identity } = vendored ?? {}
|
|
80
|
+
return { pkgDir: nm.dir, name: pkg.name, version: pkg.version, ecosystem: 'npm', ...(repo === undefined ? {} : { repo }), ...(vendored === undefined ? {} : { vendored: { [sub]: identity } }) }
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
// A file in a subpackage is its host's too: the nearest package.json with a name is walked past.
|
|
84
|
+
let subpackages
|
|
85
|
+
let nearest = true
|
|
31
86
|
for (let dir = dirname(fileRelPath); ; dir = dirname(dir)) {
|
|
32
|
-
const pkg =
|
|
33
|
-
const
|
|
34
|
-
|
|
87
|
+
const pkg = read(toPosix(join(dir, 'package.json')))
|
|
88
|
+
const posixDir = toPosix(dir)
|
|
89
|
+
const inNodeModules = hasNodeModulesSegment(posixDir)
|
|
90
|
+
const sub = pkg?.name && nm !== null ? hostSubpackageDir(read, nm.dir, posixDir, pkg.name) : undefined
|
|
91
|
+
if (sub !== undefined) {
|
|
92
|
+
if (nearest) subpackages = { [sub]: manifestIdentity(pkg) }
|
|
93
|
+
} else if (pkg?.name && (pkg.version || !inNodeModules)) {
|
|
35
94
|
const repo = inNodeModules ? packageRepo(pkg) : undefined
|
|
95
|
+
const own = posixDir === nm?.dir ? subpackages : undefined // the subpackage's package, not one above it
|
|
36
96
|
// `?? undefined` folds a literal `"version": null` into the one absent-version spelling.
|
|
37
|
-
return { pkgDir: dir, name: pkg.name, version: pkg.version ?? undefined, ...(inNodeModules ? { ecosystem: 'npm' } : {}), ...(repo === undefined ? {} : { repo }) }
|
|
97
|
+
return { pkgDir: dir, name: pkg.name, version: pkg.version ?? undefined, ...(inNodeModules ? { ecosystem: 'npm' } : {}), ...(repo === undefined ? {} : { repo }), ...(own === undefined ? {} : { subpackages: own }) }
|
|
38
98
|
}
|
|
39
|
-
if (
|
|
99
|
+
if (pkg?.name) nearest = false
|
|
100
|
+
if (dirname(dir) === dir) return null // '.' and a filesystem root are their own dirname
|
|
40
101
|
}
|
|
41
102
|
}
|
|
42
103
|
|
|
43
|
-
//
|
|
104
|
+
// Once per directory, the only thing findPackageMetadata's answer depends on.
|
|
105
|
+
export const packageLookup = (baseDir, options) => memoized((path) => findPackageMetadata(baseDir, path, options), (path) => posix.dirname(path))
|
|
106
|
+
|
|
107
|
+
function hostSubpackageDir(read, pkgDir, dir, manifestName) {
|
|
108
|
+
if (!dir.startsWith(`${pkgDir}/`)) return undefined
|
|
109
|
+
const sub = dir.slice(pkgDir.length + 1)
|
|
110
|
+
if (typeof manifestName !== 'string' || !manifestName.endsWith(`/${sub}`)) return undefined
|
|
111
|
+
return isSubpackage(manifestName, read(`${pkgDir}/package.json`)?.name, sub) ? sub : undefined
|
|
112
|
+
}
|
|
113
|
+
|
|
44
114
|
export const NO_ENTRY = new Set(['ENOENT', 'ENOTDIR'])
|
|
45
115
|
|
|
46
|
-
//
|
|
47
|
-
|
|
48
|
-
// module lookup does; real stat tells them apart: a link loop, a directory that may not be searched
|
|
49
|
-
// or a name too long is something there that can't be read, and a read meets the same error.
|
|
50
|
-
function readFailure(host, file) {
|
|
116
|
+
// A link is not followed, a broken one counted too (`host.readlink` throws when nothing is there).
|
|
117
|
+
export function lexists(p, host) {
|
|
51
118
|
try {
|
|
52
|
-
host.
|
|
119
|
+
host.readlink(p)
|
|
120
|
+
return true
|
|
53
121
|
} catch (err) {
|
|
54
|
-
|
|
122
|
+
if (NO_ENTRY.has(err.code)) return false
|
|
123
|
+
throw err
|
|
55
124
|
}
|
|
56
|
-
return new Error(`${file} could be read but not stat'ed`)
|
|
57
125
|
}
|
|
58
126
|
|
|
59
|
-
// host.stat as
|
|
60
|
-
// can't be
|
|
61
|
-
|
|
127
|
+
// host.stat answers null for any failure, as Node's module lookup does; this, only when nothing is there. Something
|
|
128
|
+
// there that can't be read (a link loop, an unsearchable directory, a too-long name) throws `fail(cause)`.
|
|
129
|
+
function statOrFail(host, file, fail) {
|
|
62
130
|
const stat = host.stat(file)
|
|
63
131
|
if (stat !== null) return stat
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
132
|
+
try {
|
|
133
|
+
host.readFile(file)
|
|
134
|
+
} catch (err) {
|
|
135
|
+
if (NO_ENTRY.has(err.code)) return null
|
|
136
|
+
throw fail(err)
|
|
137
|
+
}
|
|
138
|
+
throw fail(new Error(`${file} could be read but not stat'ed`))
|
|
67
139
|
}
|
|
68
140
|
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
export
|
|
73
|
-
|
|
74
|
-
if (stat !== null) return stat
|
|
75
|
-
const cause = readFailure(host, file)
|
|
76
|
-
if (cause === null) return null
|
|
77
|
-
throw Object.assign(new Error(`Cannot read package config ${file}: ${cause.code ?? cause.message}.`, { cause }), { code: 'ERR_INVALID_PACKAGE_CONFIG' })
|
|
78
|
-
}
|
|
141
|
+
export const statStrict = (host, file, label) =>
|
|
142
|
+
statOrFail(host, file, (cause) => new Error(`${label}: can't be read (${cause.code ?? cause.message})`, { cause }))
|
|
143
|
+
|
|
144
|
+
export const invalidPackageConfig = (path, cause) =>
|
|
145
|
+
Object.assign(new Error(`Invalid package config ${path}.`, cause === undefined ? {} : { cause }), { code: 'ERR_INVALID_PACKAGE_CONFIG' })
|
|
79
146
|
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
//
|
|
147
|
+
export const packageJSONStat = (host, file) => statOrFail(host, file, (cause) =>
|
|
148
|
+
Object.assign(new Error(`Cannot read package config ${file}: ${cause.code ?? cause.message}.`, { cause }), { code: 'ERR_INVALID_PACKAGE_CONFIG' }))
|
|
149
|
+
|
|
150
|
+
// A FIFO, a socket, a device or a link to one (`/dev/stdin`) throws rather than stalling or reading the process's input.
|
|
84
151
|
export function readRegularFileOrNull(file, label, host = diskHost) {
|
|
85
152
|
const stat = statStrict(host, file, label)
|
|
86
153
|
if (stat === null || stat.isDirectory()) return null
|
|
@@ -88,24 +155,17 @@ export function readRegularFileOrNull(file, label, host = diskHost) {
|
|
|
88
155
|
return host.readFile(file)
|
|
89
156
|
}
|
|
90
157
|
|
|
91
|
-
//
|
|
92
|
-
//
|
|
93
|
-
// when it doesn't parse, isn't a regular file or can't be read -- unless `strict`, then that throws
|
|
94
|
-
// (only nothing there is no package.json, as Node reads one: statStrict), saying where
|
|
95
|
-
// with the parser's line and column but never its message, which quotes the text (a file that isn't
|
|
96
|
-
// JSON may be anything, a secret included). `check(rel)`, when given, sees the path before it is
|
|
97
|
-
// read, and may throw to refuse it.
|
|
158
|
+
// Parsed past a BOM, as npm and Node; null when there's none or it can't be read, isn't a regular file or doesn't
|
|
159
|
+
// parse -- unless `strict`: then only nothing there is null. `check(rel)` sees the path before it is read.
|
|
98
160
|
export function readPackageJson(baseDir, rel, { strict = false, check, host = diskHost } = {}) {
|
|
99
161
|
const file = join(baseDir, rel)
|
|
100
162
|
const stat = strict ? statStrict(host, file, rel) : host.stat(file)
|
|
101
163
|
if (stat === null || stat.isDirectory()) return null
|
|
102
164
|
check?.(rel)
|
|
103
165
|
try {
|
|
104
|
-
// A FIFO, a socket or a device (or a link to one) is never read: it could stall the bundle.
|
|
105
166
|
if (!stat.isFile()) throw new Error(`${rel}: not a regular file`)
|
|
106
167
|
const bytes = host.readFile(file)
|
|
107
|
-
//
|
|
108
|
-
// have (a stray byte as U+FFFD).
|
|
168
|
+
// Lenient lookups decode it as they always have (a stray byte as U+FFFD).
|
|
109
169
|
if (strict && !isUtf8(bytes)) throw new Error(`${rel}: not valid UTF-8`)
|
|
110
170
|
return parseJson(packageJSONText(bytes), rel)
|
|
111
171
|
} catch (err) {
|
|
@@ -114,8 +174,7 @@ export function readPackageJson(baseDir, rel, { strict = false, check, host = di
|
|
|
114
174
|
}
|
|
115
175
|
}
|
|
116
176
|
|
|
117
|
-
//
|
|
118
|
-
// message, which quotes the text.
|
|
177
|
+
// Never the parser's message, which quotes the text (a file that isn't JSON may be anything, a secret included).
|
|
119
178
|
function parseJson(text, rel) {
|
|
120
179
|
try {
|
|
121
180
|
return JSON.parse(text)
|
|
@@ -135,8 +194,7 @@ export function normalizeEntries(entries, cwd) {
|
|
|
135
194
|
})
|
|
136
195
|
}
|
|
137
196
|
|
|
138
|
-
//
|
|
139
|
-
// read (statStrict) or isn't UTF-8 aborts (never silently skipped).
|
|
197
|
+
// One that can't be read or isn't UTF-8 aborts, never silently skipped.
|
|
140
198
|
export function readModuleManifest({ baseDir, realBase, rel, host = diskHost } = {}) {
|
|
141
199
|
const absolute = join(baseDir, rel)
|
|
142
200
|
if (statStrict(host, absolute, rel) === null) return null
|
|
@@ -155,30 +213,24 @@ export function readJson(file, host = diskHost) {
|
|
|
155
213
|
}
|
|
156
214
|
}
|
|
157
215
|
|
|
158
|
-
//
|
|
159
|
-
//
|
|
160
|
-
// a `?` or `\` ending the authority early (`https://evil.example?@github.com/a/b`) isn't GitHub's. An
|
|
161
|
-
// scp-like `git@github.com:owner/name` is taken behind an `ssh://` too (`git+ssh://git@github.com:o/n`),
|
|
162
|
-
// as package.json files spell it. The host is GitHub's with a `www.` too, which is stripped.
|
|
216
|
+
// Userinfo holds only what RFC 3986 allows: a `?` or `\` ending the authority early isn't GitHub's
|
|
217
|
+
// (`https://evil.example?@github.com/a/b`). scp-like `git@github.com:o/n` is taken behind `ssh://` too.
|
|
163
218
|
export function parseGithubRepository(url) {
|
|
164
219
|
if (typeof url !== 'string') return null
|
|
165
220
|
const match = /^(?:github:|(?:git\+)?(?:(?:https?|ssh|git):\/\/(?:[\w.~%!$&'()*+,;=:-]*@)?(?:www\.)?github\.com(?::\d+)?\/|ssh:\/\/(?:[\w.~%!$&'()*+,;=-]*@)?(?:www\.)?github\.com:|(?:[^@/:]+@)?(?:www\.)?github\.com:))?([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/iu.exec(url.trim().replace(/#.*$/su, ''))
|
|
166
|
-
// Must also pass the bundle format's `github` check.
|
|
167
221
|
const github = match && `${match[1]}/${match[2]}`
|
|
168
222
|
return github && isValidRepoField('github', github) ? github : null
|
|
169
223
|
}
|
|
170
224
|
|
|
171
|
-
//
|
|
225
|
+
// A literal match of git's own `.git/config` layout, no parsing.
|
|
172
226
|
const GIT_ORIGIN_URL = '[remote "origin"]\n\turl = '
|
|
173
227
|
export function gitOriginUrl(text) {
|
|
174
228
|
const at = text?.indexOf(GIT_ORIGIN_URL) ?? -1
|
|
175
229
|
if (at === -1) return null
|
|
176
|
-
|
|
177
|
-
const end = text.indexOf('\n', start)
|
|
178
|
-
return text.slice(start, end === -1 ? undefined : end).trim() || null
|
|
230
|
+
return text.slice(at + GIT_ORIGIN_URL.length).split('\n', 1)[0].trim() || null
|
|
179
231
|
}
|
|
180
232
|
|
|
181
|
-
//
|
|
233
|
+
// Read through `host` (never the --fs-patched fs), it is never captured.
|
|
182
234
|
export const readText = (host, file) => {
|
|
183
235
|
try {
|
|
184
236
|
return host.readFile(file).toString('utf8')
|
|
@@ -187,7 +239,7 @@ export const readText = (host, file) => {
|
|
|
187
239
|
}
|
|
188
240
|
}
|
|
189
241
|
|
|
190
|
-
//
|
|
242
|
+
// The branch is taken as one segment: one holding a `/` reads as part of the dir.
|
|
191
243
|
export function githubHomepageDirectory(homepage, github) {
|
|
192
244
|
if (typeof homepage !== 'string') return undefined
|
|
193
245
|
const match = /^https?:\/\/(?:www\.)?github\.com\/([^/]+\/[^/]+)\/tree\/[^/#?]+\/([^#?]+)/iu.exec(homepage.trim())
|
|
@@ -199,17 +251,12 @@ export function githubHomepageDirectory(homepage, github) {
|
|
|
199
251
|
}
|
|
200
252
|
}
|
|
201
253
|
|
|
202
|
-
// `{ directory }` where it is a valid one, else `{}`.
|
|
203
254
|
const repoLocation = (directory) => (isValidRepoField('directory', directory) ? { directory } : {})
|
|
204
255
|
|
|
205
|
-
// Whether a declared path is the repository's root: nothing but empty and `.` parts (`./`, `/.`).
|
|
206
256
|
const isRootPath = (path) => path.replaceAll('\\', '/').split('/').every((part) => part === '' || part === '.')
|
|
207
257
|
|
|
208
|
-
//
|
|
209
|
-
//
|
|
210
|
-
// would come to (`a/..` is no claim on the root). Its empty and `.` parts are dropped, and one that
|
|
211
|
-
// comes to the root (`''`, `.`, `./`, `/`, `/.`) is the root, `''`. Windows users write `base` with
|
|
212
|
-
// `\`: metadata, not a name on disk, so its `\` is taken for a separator.
|
|
258
|
+
// `{}` where none is declared (unknown, not the root) or `base` has a `..` part (`a/..` is no claim on the root).
|
|
259
|
+
// Its `\` is a separator: Windows users write it so, and it is metadata, not a name on disk.
|
|
213
260
|
const declaredLocation = (base, rel) => {
|
|
214
261
|
if (typeof base !== 'string') return {}
|
|
215
262
|
const path = base.replaceAll('\\', '/')
|
|
@@ -218,7 +265,6 @@ const declaredLocation = (base, rel) => {
|
|
|
218
265
|
return repoLocation(directory === '.' ? '' : directory)
|
|
219
266
|
}
|
|
220
267
|
|
|
221
|
-
// Git and common dirs, following a worktree/submodule `.git` file.
|
|
222
268
|
function gitDirs(dotGit, host) {
|
|
223
269
|
const pointer = readText(host, dotGit) // null for a `.git` directory (EISDIR)
|
|
224
270
|
const gitDir = pointer?.startsWith('gitdir: ') ? resolve(dirname(dotGit), pointer.slice('gitdir: '.length).trim()) : dotGit
|
|
@@ -226,7 +272,6 @@ function gitDirs(dotGit, host) {
|
|
|
226
272
|
return { gitDir, commonDir: common ? resolve(gitDir, common) : gitDir }
|
|
227
273
|
}
|
|
228
274
|
|
|
229
|
-
// HEAD's commit: detached sha, loose ref, or packed-refs; undefined unless a valid sha.
|
|
230
275
|
function gitHeadCommit({ gitDir, commonDir }, host) {
|
|
231
276
|
const head = readText(host, join(gitDir, 'HEAD'))?.trim()
|
|
232
277
|
if (!head) return undefined
|
|
@@ -240,30 +285,23 @@ function gitHeadCommit({ gitDir, commonDir }, host) {
|
|
|
240
285
|
return isValidRepoField('commit', commit) ? commit : undefined
|
|
241
286
|
}
|
|
242
287
|
|
|
243
|
-
//
|
|
244
|
-
// file of a submodule or worktree; undefined where it holds none. Read through `host`, under `.git`
|
|
245
|
-
// alone; git never runs.
|
|
288
|
+
// Read through `host`, under `.git` alone; git never runs.
|
|
246
289
|
export function checkoutCommit(dir, host = diskHost) {
|
|
247
290
|
const dotGit = join(dir, '.git')
|
|
248
291
|
return host.stat(dotGit) === null ? undefined : gitHeadCommit(gitDirs(dotGit, host), host)
|
|
249
292
|
}
|
|
250
293
|
|
|
251
|
-
// A parsed package.json's `repository` url (the string shorthand, or its `url`), or undefined.
|
|
252
294
|
function repositoryUrl(json) {
|
|
253
295
|
const repository = json?.repository
|
|
254
296
|
const url = typeof repository === 'string' ? repository : repository?.url
|
|
255
297
|
return typeof url === 'string' ? url : undefined
|
|
256
298
|
}
|
|
257
299
|
|
|
258
|
-
|
|
259
|
-
// own): `github` from its GitHub URL or shorthand, and `directory` from `repository.directory` joined
|
|
260
|
-
// with `rel` (declaredLocation); undefined where it names no GitHub repository.
|
|
261
|
-
export function packageRepo(json, rel = '') {
|
|
300
|
+
function declaredRepo(json, rel) {
|
|
262
301
|
const github = parseGithubRepository(repositoryUrl(json))
|
|
263
302
|
if (!github) return undefined
|
|
264
303
|
let base = json.repository.directory
|
|
265
|
-
// Often unset;
|
|
266
|
-
// at it: only `repository.directory` declares the root (`/tree/main/.` declares nothing).
|
|
304
|
+
// Often unset; a GitHub tree `homepage` places a package below the root, never at it (`/tree/main/.` declares nothing).
|
|
267
305
|
if (typeof base !== 'string') {
|
|
268
306
|
base = githubHomepageDirectory(json.homepage, github)
|
|
269
307
|
if (base !== undefined && isRootPath(base)) base = undefined
|
|
@@ -271,8 +309,13 @@ export function packageRepo(json, rel = '') {
|
|
|
271
309
|
return { github, ...declaredLocation(base, rel) }
|
|
272
310
|
}
|
|
273
311
|
|
|
274
|
-
//
|
|
275
|
-
|
|
312
|
+
// lerna writes `gitHead` into package.json too (npm publish only into the registry's document), and npm keeps it.
|
|
313
|
+
export function packageRepo(json) {
|
|
314
|
+
const repo = declaredRepo(json, '')
|
|
315
|
+
return repo !== undefined && isValidRepoField('commit', json.gitHead) ? { ...repo, commit: json.gitHead } : repo
|
|
316
|
+
}
|
|
317
|
+
|
|
318
|
+
// Its commit is git's HEAD alone, never a package.json's `gitHead`: a project's own files likely changed since.
|
|
276
319
|
export function detectRepo(dir, host = diskHost) {
|
|
277
320
|
const start = resolve(dir)
|
|
278
321
|
let pkg = null // null: no package.json `repository` seen yet; undefined: one seen, not GitHub
|
|
@@ -280,17 +323,16 @@ export function detectRepo(dir, host = diskHost) {
|
|
|
280
323
|
const rel = toPosix(relative(cursor, start))
|
|
281
324
|
if (pkg === null) {
|
|
282
325
|
const json = readJson(join(cursor, 'package.json'), host)
|
|
283
|
-
if (repositoryUrl(json) !== undefined) pkg =
|
|
326
|
+
if (repositoryUrl(json) !== undefined) pkg = declaredRepo(json, rel)
|
|
284
327
|
}
|
|
285
328
|
const dotGit = join(cursor, '.git')
|
|
286
329
|
if (host.stat(dotGit) !== null) {
|
|
287
330
|
const dirs = gitDirs(dotGit, host)
|
|
288
331
|
const github = parseGithubRepository(gitOriginUrl(readText(host, join(dirs.commonDir, 'config'))))
|
|
289
|
-
if (github) return
|
|
290
|
-
|
|
332
|
+
if (!github) return pkg ?? undefined
|
|
333
|
+
const commit = gitHeadCommit(dirs, host)
|
|
334
|
+
return { github, ...repoLocation(rel), ...(commit === undefined ? {} : { commit }) }
|
|
291
335
|
}
|
|
292
336
|
if (dirname(cursor) === cursor) return pkg ?? undefined
|
|
293
337
|
}
|
|
294
338
|
}
|
|
295
|
-
|
|
296
|
-
const stripUndefined = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined))
|