@exodus/stasis 1.0.0-beta.13 → 1.0.0-beta.15
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/README.md +5 -1
- package/bin/stasis.js +191 -149
- package/package.json +31 -7
- package/src/audit.js +224 -90
- package/src/babel.js +44 -37
- package/src/bundle-reader.js +24 -4
- package/src/cmd/build.js +218 -8
- package/src/cmd/bundle-options.js +31 -25
- package/src/cmd/bundle.js +1147 -311
- package/src/cmd/github-bundle.js +17 -9
- package/src/cmd/output.js +10 -3
- package/src/cmd/tokens.js +73 -0
- package/src/define.js +5 -0
- package/src/diff.js +2 -2
- package/src/flow.js +42 -0
- package/src/installed-commits.js +4 -2
- package/src/loaders/bash.js +2 -27
- package/src/loaders/cargo.js +6 -6
- package/src/loaders/foundry.js +4 -6
- package/src/loaders/paths.js +4 -15
- package/src/loaders/php.js +3 -5
- package/src/loaders/rust.js +19 -39
- package/src/loaders/solidity-ownership.js +4 -15
- package/src/loaders/solidity.js +4 -67
- package/src/metro-assets.js +65 -0
- package/src/metro-resolver.js +76 -123
- package/src/parse.js +7 -3
- package/src/resolve-fields.js +133 -366
- package/src/resolve-node.js +9 -7
- package/src/resolve-typescript.js +102 -30
- package/src/scan.js +154 -54
- package/src/sixel.js +333 -0
- package/src/table.js +116 -0
- package/src/validate-notes.d.ts +18 -0
- package/src/validate-notes.js +66 -0
- package/src/validate.d.ts +132 -0
- package/src/validate.js +1349 -0
- package/src/vfs-bundle/entries.js +5 -2
- package/src/vfs-bundle/github.js +68 -19
- package/src/vfs-bundle/glob.js +420 -0
- package/src/vfs-bundle/lazy.js +128 -0
- package/src/vfs-bundle/prisma.js +102 -29
- package/src/vfs-bundle/tree.js +238 -75
- package/src/vfs-bundle/yarnclean.js +100 -0
- package/src/vfs-bundle.js +16 -7
- package/src/why.js +9 -7
|
@@ -9,7 +9,7 @@ import { configuredBuilds } from '../cmd/bundle-options.js'
|
|
|
9
9
|
import { foundrySourceDir } from '../loaders/foundry.js'
|
|
10
10
|
import { resolveConditions } from '../resolve-fields.js'
|
|
11
11
|
import { resolveTypescriptFallback, typescriptExportsTarget } from '../resolve-typescript.js'
|
|
12
|
-
import { checkKind, checkVersion, packageManagerOf, vfsHost } from './tree.js'
|
|
12
|
+
import { checkKind, checkLazy, checkVersion, packageManagerOf, vfsHost } from './tree.js'
|
|
13
13
|
|
|
14
14
|
const JS = /\.(?:[cm]?[jt]s|[jt]sx)$/u
|
|
15
15
|
// Node's own conditions for require() and for import, which the build's are added to; with
|
|
@@ -144,10 +144,13 @@ export function defaultEntries(name, host, dir, kind, options) {
|
|
|
144
144
|
// decides them: for the package manager given, else for any; over the entries given, else over one
|
|
145
145
|
// of the kind the default ones are. But for what one of them needs of another, which the options of
|
|
146
146
|
// an entry stasis.config.json names may set (`partial`), left to the build, which knows whether it
|
|
147
|
-
// names it. -> the PACKAGE_MANAGERS entry of
|
|
147
|
+
// names it; and `lazy`, which the package manager given has to take. -> the PACKAGE_MANAGERS entry of
|
|
148
|
+
// the one given
|
|
148
149
|
export function checkAhead(name, packageManager, options) {
|
|
149
150
|
checkVersion(name, { packageManager, ...options })
|
|
151
|
+
if (options.lazy !== undefined && typeof options.lazy !== 'boolean') throw new TypeError(`${name}: lazy must be a boolean`)
|
|
150
152
|
const pm = packageManager === undefined ? undefined : packageManagerOf(name, packageManager)
|
|
153
|
+
if (options.lazy && pm !== undefined) checkLazy(name, packageManager)
|
|
151
154
|
const refusal = (entries) => {
|
|
152
155
|
try {
|
|
153
156
|
checkKind(name, checkVfsOptions(name, { ...options, entries, cwd: '/', host: EMPTY, fetched: false, partial: true }), packageManager === undefined ? undefined : [packageManager])
|
package/src/vfs-bundle/github.js
CHANGED
|
@@ -6,9 +6,10 @@ import { decompress } from '@preventive/archive/compression.js'
|
|
|
6
6
|
import { ArchiveError, unpack } from '@preventive/archive/tar.js'
|
|
7
7
|
import { createClient } from '@preventive/upstream/github.js'
|
|
8
8
|
import { vfsFromEntries } from '@preventive/vfs'
|
|
9
|
-
import { buildVfsBundle } from '../cmd/bundle.js'
|
|
9
|
+
import { buildVfsBundle, debugTimed } from '../cmd/bundle.js'
|
|
10
10
|
import { KINDS, checkAhead, defaultEntries } from './entries.js'
|
|
11
11
|
import { checkCache, checkTarget, detectPackageManager, installedAlone, lockfileOf, lockfilesListed, noLockfile, packageManagerOf, vfsHost } from './tree.js'
|
|
12
|
+
import { YARNCLEAN } from './yarnclean.js'
|
|
12
13
|
|
|
13
14
|
// As upstream's tree verification bounds a tarball's unpacked size.
|
|
14
15
|
const MAX_TAR_BYTES = 2 ** 30
|
|
@@ -79,14 +80,45 @@ async function repoFiles(client, { github, sha, where }) {
|
|
|
79
80
|
return files
|
|
80
81
|
}
|
|
81
82
|
|
|
82
|
-
// Checked as the Bundle checks them, before anything is fetched; a tag's name is upstream's to check
|
|
83
|
-
|
|
83
|
+
// Checked as the Bundle checks them, before anything is fetched; a tag's name is upstream's to check,
|
|
84
|
+
// and a `path` is checked as a `directory`, which it may be.
|
|
85
|
+
function checkRepo(name, { github, sha, tag, directory, path }) {
|
|
84
86
|
if (github === undefined) throw new Error(`${name}: github is required`)
|
|
85
87
|
if (tag !== undefined && (typeof tag !== 'string' || tag === '')) throw new TypeError(`${name}: tag must be a non-empty string`)
|
|
86
88
|
if (sha !== undefined && tag !== undefined) throw new Error(`${name}: sha and tag both name the commit: give one`)
|
|
89
|
+
if (directory !== undefined && path !== undefined) throw new Error(`${name}: directory and path both name the directory: give one`)
|
|
87
90
|
for (const [key, value] of Object.entries({ github, commit: sha, directory: directory || undefined })) {
|
|
88
91
|
if (value !== undefined && !isValidRepoField(key, value)) throw new Error(`${name}: invalid ${key}: ${JSON.stringify(value)}`)
|
|
89
92
|
}
|
|
93
|
+
if (path && !isValidRepoField('directory', path)) throw new Error(`${name}: invalid path: ${JSON.stringify(path)}`)
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// The files that make a directory a project's root, for an entry of each kind: a JS project's
|
|
97
|
+
// package.json, and the foundry.toml or soldeer.toml Soldeer installs from.
|
|
98
|
+
const PROJECT_FILES = { js: ['package.json'], sol: ['foundry.toml', 'soldeer.toml'] }
|
|
99
|
+
// A symlink's mode in a git tree.
|
|
100
|
+
const SYMLINK = '120000'
|
|
101
|
+
|
|
102
|
+
// `path` in the repo, by `list`'s listings, as `{ directory, entry }`: a file (no symlink) is an
|
|
103
|
+
// entry of the nearest directory at or above it holding one of PROJECT_FILES of its kind, the repo's
|
|
104
|
+
// root (undefined) where none does, and a path from there; anything else, or what the listings can't
|
|
105
|
+
// tell (a symlink on the way), is the directory, with no entry.
|
|
106
|
+
async function splitPath(list, path) {
|
|
107
|
+
const above = ancestorsOf(path)
|
|
108
|
+
let listings
|
|
109
|
+
try {
|
|
110
|
+
listings = await Promise.all(above.map(list))
|
|
111
|
+
} catch {
|
|
112
|
+
// No plain directory in git (a symlink, or under one); the root's failure is GitHub's.
|
|
113
|
+
await list(undefined)
|
|
114
|
+
return { directory: path }
|
|
115
|
+
}
|
|
116
|
+
const name = posix.basename(path)
|
|
117
|
+
if (!listings[0].some((entry) => entry.path === name && entry.type === 'blob' && entry.mode !== SYMLINK)) return { directory: path }
|
|
118
|
+
const files = PROJECT_FILES[path.endsWith('.sol') ? 'sol' : 'js']
|
|
119
|
+
const at = listings.findIndex((listing) => listing.some((entry) => files.includes(entry.path) && entry.type === 'blob'))
|
|
120
|
+
const directory = at === -1 ? undefined : above[at]
|
|
121
|
+
return { directory, entry: directory === undefined ? path : posix.relative(directory, path) }
|
|
90
122
|
}
|
|
91
123
|
|
|
92
124
|
// listRepoDir's listing of a directory of the repo at `sha`, each listed once.
|
|
@@ -116,7 +148,7 @@ async function listedPackageManager(list, { directory, where }) {
|
|
|
116
148
|
}
|
|
117
149
|
|
|
118
150
|
// The files of `directory` alone, when it holds the lockfile, is installed from itself and stands
|
|
119
|
-
// alone; else null.
|
|
151
|
+
// alone, nor does a .yarnclean above it clean the node_modules it installs; else null.
|
|
120
152
|
async function subtreeEntries(client, list, { github, directory, packageManager, where }) {
|
|
121
153
|
const names = async (path) => (await list(path)).map((entry) => entry.path)
|
|
122
154
|
let listing
|
|
@@ -129,6 +161,7 @@ async function subtreeEntries(client, list, { github, directory, packageManager,
|
|
|
129
161
|
const above = ancestorsOf(directory)
|
|
130
162
|
// Installed from a root above it (a workspace's), it is built from there.
|
|
131
163
|
if (!(await installedAlone(packageManager, listing.map((entry) => entry.path), () => Promise.all(above.map(names))))) return null
|
|
164
|
+
if (packageManagerOf('buildGitHubBundle', packageManager).kind === 'js' && (await Promise.all(above.map(names))).some((dir) => dir.includes(YARNCLEAN))) return null
|
|
132
165
|
// Its tree id, as the listing above it holds it, held to that directory's own.
|
|
133
166
|
const tree = (await list(above[0])).find((entry) => entry.path === posix.basename(directory) && entry.type === 'tree')?.sha
|
|
134
167
|
const files = tree === undefined ? null : await treeFiles(client, { github, tree, directory, where })
|
|
@@ -139,15 +172,24 @@ async function subtreeEntries(client, list, { github, directory, packageManager,
|
|
|
139
172
|
// annotated tag followed to it), else the default branch's head; `directory` alone where it stands
|
|
140
173
|
// alone for the package manager installing it, else the whole repo. That package manager is
|
|
141
174
|
// `packageManager` if given, else the one the listings tell, before the tree is fetched, else the
|
|
142
|
-
// tree; `options` are checked for it once it is known.
|
|
143
|
-
//
|
|
144
|
-
|
|
175
|
+
// tree; `options` are checked for it once it is known. A `path` is the `directory`, or a file in
|
|
176
|
+
// it which is an entry ahead of `options.entries` (splitPath).
|
|
177
|
+
// -> { vfs, host, cwd, subtree, sha, where, packageManager, kind, directory, entries }
|
|
178
|
+
async function repoTree(name, { github, sha, tag, directory, path, client, packageManager }, options) {
|
|
145
179
|
checkAhead(name, packageManager, options)
|
|
146
|
-
checkRepo(name, { github, sha, tag, directory })
|
|
180
|
+
checkRepo(name, { github, sha, tag, directory, path })
|
|
147
181
|
client ??= createClient({ token: null })
|
|
148
182
|
sha ??= tag === undefined ? (await client.getRepoHead({ repo: github })).oid : (await client.getRepoTag({ repo: github, tag })).oid
|
|
149
183
|
const where = `${name}: ${github}@${sha}`
|
|
150
184
|
const list = lister(client, { github, sha })
|
|
185
|
+
if (path) {
|
|
186
|
+
const split = await splitPath(list, path)
|
|
187
|
+
directory = split.directory
|
|
188
|
+
if (split.entry !== undefined) {
|
|
189
|
+
options = { ...options, entries: [split.entry, ...(options.entries ?? [])] }
|
|
190
|
+
checkAhead(name, packageManager, options)
|
|
191
|
+
}
|
|
192
|
+
}
|
|
151
193
|
let found = packageManager
|
|
152
194
|
if (found === undefined) {
|
|
153
195
|
found = await listedPackageManager(list, { directory, where })
|
|
@@ -162,7 +204,7 @@ async function repoTree(name, { github, sha, tag, directory, client, packageMana
|
|
|
162
204
|
if (detected !== found) checkAhead(name, detected, options)
|
|
163
205
|
found = detected
|
|
164
206
|
}
|
|
165
|
-
return { vfs, host, cwd, subtree, sha, where, packageManager: found, kind: KINDS[packageManagerOf(name, found).kind] }
|
|
207
|
+
return { vfs, host, cwd, subtree, sha, where, packageManager: found, kind: KINDS[packageManagerOf(name, found).kind], directory, entries: options.entries }
|
|
166
208
|
}
|
|
167
209
|
|
|
168
210
|
// A GitHub repo at a full commit, or the one `tag` names, the default branch's head without either,
|
|
@@ -175,32 +217,39 @@ async function repoTree(name, { github, sha, tag, directory, client, packageMana
|
|
|
175
217
|
// one is outside the others; `repo` names that directory and the commit. Nothing is read from disk:
|
|
176
218
|
// the tree's bytes come from GitHub, or from the cache setCacheDir names, held to the git tree id
|
|
177
219
|
// either way (@preventive/upstream), and are unpacked into a Vfs that buildVfsBundle reads alone.
|
|
178
|
-
// `cache`
|
|
179
|
-
// where setCacheDir says, whatever it is.
|
|
180
|
-
|
|
220
|
+
// `cache` and `lazy` are buildVfsBundle's, for the npm packages the tree installs: the repo's tree is
|
|
221
|
+
// cached where setCacheDir says, whatever it is, and fetched whole.
|
|
222
|
+
// `path`, in place of `directory`, is a path in the repo at the commit: a directory is the
|
|
223
|
+
// `directory`, and a file an entry ahead of `entries`, of the nearest directory at or above it with
|
|
224
|
+
// a package.json (with a foundry.toml or soldeer.toml, for a .sol file), else of the repo's root,
|
|
225
|
+
// which is then the `directory` (splitPath).
|
|
226
|
+
// -> buildVfsBundle's, and the `directory` bundled
|
|
227
|
+
export async function buildGitHubBundle({ github, sha, tag, directory, path, client, packageManager, ...options } = {}) {
|
|
181
228
|
checkTarget('buildGitHubBundle', options)
|
|
182
229
|
checkCache('buildGitHubBundle', options.cache)
|
|
183
230
|
// Its own, for a Soldeer git dependency too.
|
|
184
231
|
client ??= createClient({ token: null })
|
|
185
|
-
const tree = await repoTree('buildGitHubBundle', { github, sha, tag, directory, client, packageManager }, options)
|
|
186
|
-
let { entries } =
|
|
232
|
+
const tree = await debugTimed('Fetched the repo', () => repoTree('buildGitHubBundle', { github, sha, tag, directory, path, client, packageManager }, options))
|
|
233
|
+
let { entries } = tree
|
|
187
234
|
if (entries === undefined) {
|
|
188
235
|
// As suggestedEntries suggests them, from the tree at hand.
|
|
189
236
|
const suggested = defaultEntries('buildGitHubBundle', tree.host, tree.cwd, tree.kind, options)
|
|
190
237
|
entries = suggested.entries
|
|
191
|
-
if (entries.length === 0) throw new Error(`${tree.where}: no entries given, and ${directory || 'the repo root'} ${suggested.none}`)
|
|
238
|
+
if (entries.length === 0) throw new Error(`${tree.where}: no entries given, and ${tree.directory || 'the repo root'} ${suggested.none}`)
|
|
192
239
|
}
|
|
193
240
|
const repo = { github, commit: tree.sha }
|
|
194
241
|
const built = await buildVfsBundle({ ...options, entries, packageManager: tree.packageManager, vfs: tree.vfs, cwd: tree.cwd, innermostRoot: true, repo, client })
|
|
195
242
|
// The Vfs is the repo's tree, or the subtree at `directory`: a layout known, so its root is `''`.
|
|
196
|
-
const at = posix.join(tree.subtree ? directory : '.', posix.relative('/', built.root)).replace(/^\.$/u, '')
|
|
243
|
+
const at = posix.join(tree.subtree ? tree.directory : '.', posix.relative('/', built.root)).replace(/^\.$/u, '')
|
|
197
244
|
built.bundle.repo = { ...repo, ...(isValidRepoField('directory', at) ? { directory: at } : {}) }
|
|
245
|
+
// Onto buildVfsBundle's own, not a copy, which would read its lockfile, built only when read.
|
|
246
|
+
built.directory = tree.directory
|
|
198
247
|
return built
|
|
199
248
|
}
|
|
200
249
|
|
|
201
|
-
// suggestedEntries of a GitHub repo, `{ github, sha, tag, directory, client, packageManager }`,
|
|
202
|
-
// buildGitHubBundle downloads it.
|
|
250
|
+
// suggestedEntries of a GitHub repo, `{ github, sha, tag, directory | path, client, packageManager }`,
|
|
251
|
+
// as buildGitHubBundle downloads it: a `path` to a file, that file.
|
|
203
252
|
export async function suggestedRepoEntries(repo, resolution) {
|
|
204
253
|
const tree = await repoTree('suggestedEntries', repo, resolution)
|
|
205
|
-
return defaultEntries('suggestedEntries', tree.host, tree.cwd, tree.kind, resolution).entries
|
|
254
|
+
return tree.entries ?? defaultEntries('suggestedEntries', tree.host, tree.cwd, tree.kind, resolution).entries
|
|
206
255
|
}
|
|
@@ -0,0 +1,420 @@
|
|
|
1
|
+
import { createRequire } from 'node:module'
|
|
2
|
+
import { posix } from 'node:path'
|
|
3
|
+
|
|
4
|
+
// Node's own fs.globSync and path.matchesGlob over a `host` (@exodus/stasis-core/host) in place of
|
|
5
|
+
// the disk, for a Vfs's: Node 24.22.2's and 26.13.0's internal/fs/glob.js, its globSync as it runs
|
|
6
|
+
// without `followSymlinks`, `maxDepth` or an array `exclude`, over the minimatch 10 they vendor, an
|
|
7
|
+
// optional dependency loaded where a pattern is first matched. Unlike Node's, matching never folds
|
|
8
|
+
// case, whatever the OS: the tree is git's, whose names differ by case alone.
|
|
9
|
+
|
|
10
|
+
const { join, resolve } = posix
|
|
11
|
+
const require = createRequire(import.meta.url)
|
|
12
|
+
|
|
13
|
+
const MINIMATCH = 'minimatch'
|
|
14
|
+
const MINIMATCH_MAJOR = '10'
|
|
15
|
+
// Node's createMatcher's, as on Linux.
|
|
16
|
+
const OPTIONS = { nocase: false, windowsPathsNoEscape: true, nonegate: true, nocomment: true, optimizationLevel: 2, platform: 'linux', nocaseMagicOnly: true }
|
|
17
|
+
|
|
18
|
+
let minimatch
|
|
19
|
+
// minimatch, or a refusal naming `what` needs it where it isn't installed.
|
|
20
|
+
export function loadMinimatch(what) {
|
|
21
|
+
if (minimatch) return minimatch
|
|
22
|
+
const needs = `${what} needs the optional '${MINIMATCH}' ${MINIMATCH_MAJOR} dependency`
|
|
23
|
+
let version
|
|
24
|
+
try {
|
|
25
|
+
version = require(`${MINIMATCH}/package.json`).version
|
|
26
|
+
} catch (cause) {
|
|
27
|
+
throw new Error(`${needs}; install it (e.g. \`npm i ${MINIMATCH}@${MINIMATCH_MAJOR}\`)`, { cause })
|
|
28
|
+
}
|
|
29
|
+
// Another package's, found where the optional one isn't installed.
|
|
30
|
+
if (version.split('.')[0] !== MINIMATCH_MAJOR) throw new Error(`${needs}, not ${version}`)
|
|
31
|
+
minimatch = require(MINIMATCH)
|
|
32
|
+
return minimatch
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
const lazyMinimatch = () => loadMinimatch("A glob over a Vfs (stasis.config.json's extra)")
|
|
36
|
+
|
|
37
|
+
// Throws where globbing a Vfs can't load minimatch, before anything else is done.
|
|
38
|
+
export const checkGlob = () => void lazyMinimatch()
|
|
39
|
+
|
|
40
|
+
const createMatcher = (pattern) => new (lazyMinimatch().Minimatch)(pattern, OPTIONS)
|
|
41
|
+
|
|
42
|
+
// What `host` holds at `path`, its last link not followed, as far as the walk asks of lstat's
|
|
43
|
+
// Dirent; null where nothing is.
|
|
44
|
+
function lstatOf(host, path) {
|
|
45
|
+
let link
|
|
46
|
+
try {
|
|
47
|
+
link = host.readlink(path)
|
|
48
|
+
} catch {
|
|
49
|
+
return null
|
|
50
|
+
}
|
|
51
|
+
const directory = link === null ? host.stat(path)?.isDirectory() : false
|
|
52
|
+
if (directory === undefined) return null
|
|
53
|
+
return { isDirectory: () => directory, isSymbolicLink: () => link !== null }
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
class Cache {
|
|
57
|
+
#host
|
|
58
|
+
#cache = new Map()
|
|
59
|
+
#statsCache = new Map()
|
|
60
|
+
#readdirCache = new Map()
|
|
61
|
+
|
|
62
|
+
constructor(host) {
|
|
63
|
+
this.#host = host
|
|
64
|
+
}
|
|
65
|
+
statSync(path) {
|
|
66
|
+
const cached = this.#statsCache.get(path)
|
|
67
|
+
if (cached) {
|
|
68
|
+
return cached
|
|
69
|
+
}
|
|
70
|
+
const val = lstatOf(this.#host, path)
|
|
71
|
+
this.#statsCache.set(path, val)
|
|
72
|
+
return val
|
|
73
|
+
}
|
|
74
|
+
addToStatCache(path, val) {
|
|
75
|
+
this.#statsCache.set(path, val)
|
|
76
|
+
}
|
|
77
|
+
readdirSync(path) {
|
|
78
|
+
const cached = this.#readdirCache.get(path)
|
|
79
|
+
if (cached) {
|
|
80
|
+
return cached
|
|
81
|
+
}
|
|
82
|
+
let val
|
|
83
|
+
try {
|
|
84
|
+
val = this.#host.readdir(path)
|
|
85
|
+
} catch {
|
|
86
|
+
val = []
|
|
87
|
+
}
|
|
88
|
+
this.#readdirCache.set(path, val)
|
|
89
|
+
return val
|
|
90
|
+
}
|
|
91
|
+
add(path, pattern) {
|
|
92
|
+
let cache = this.#cache.get(path)
|
|
93
|
+
if (!cache) {
|
|
94
|
+
cache = new Set()
|
|
95
|
+
this.#cache.set(path, cache)
|
|
96
|
+
}
|
|
97
|
+
const originalSize = cache.size
|
|
98
|
+
pattern.indexes.forEach((index) => cache.add(pattern.cacheKey(index)))
|
|
99
|
+
return cache.size !== originalSize + pattern.indexes.size
|
|
100
|
+
}
|
|
101
|
+
seen(path, pattern, index) {
|
|
102
|
+
return this.#cache.get(path)?.has(pattern.cacheKey(index))
|
|
103
|
+
}
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
class Pattern {
|
|
107
|
+
#pattern
|
|
108
|
+
#globStrings
|
|
109
|
+
indexes
|
|
110
|
+
symlinks
|
|
111
|
+
last
|
|
112
|
+
|
|
113
|
+
constructor(pattern, globStrings, indexes, symlinks) {
|
|
114
|
+
this.#pattern = pattern
|
|
115
|
+
this.#globStrings = globStrings
|
|
116
|
+
this.indexes = indexes
|
|
117
|
+
this.symlinks = symlinks
|
|
118
|
+
this.last = pattern.length - 1
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
isLast(isDirectory) {
|
|
122
|
+
return this.indexes.has(this.last) ||
|
|
123
|
+
(this.at(-1) === '' && isDirectory &&
|
|
124
|
+
this.indexes.has(this.last - 1) && this.at(-2) === lazyMinimatch().GLOBSTAR)
|
|
125
|
+
}
|
|
126
|
+
isFirst() {
|
|
127
|
+
return this.indexes.has(0)
|
|
128
|
+
}
|
|
129
|
+
get hasSeenSymlinks() {
|
|
130
|
+
return [...this.indexes].some((i) => !this.symlinks.has(i))
|
|
131
|
+
}
|
|
132
|
+
at(index) {
|
|
133
|
+
return this.#pattern.at(index)
|
|
134
|
+
}
|
|
135
|
+
child(indexes, symlinks = new Set()) {
|
|
136
|
+
return new Pattern(this.#pattern, this.#globStrings, indexes, symlinks)
|
|
137
|
+
}
|
|
138
|
+
test(index, path) {
|
|
139
|
+
if (index > this.#pattern.length) {
|
|
140
|
+
return false
|
|
141
|
+
}
|
|
142
|
+
const pattern = this.#pattern[index]
|
|
143
|
+
if (pattern === lazyMinimatch().GLOBSTAR) {
|
|
144
|
+
return true
|
|
145
|
+
}
|
|
146
|
+
if (typeof pattern === 'string') {
|
|
147
|
+
return pattern === path
|
|
148
|
+
}
|
|
149
|
+
if (typeof pattern?.test === 'function') {
|
|
150
|
+
return pattern.test(path)
|
|
151
|
+
}
|
|
152
|
+
return false
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
cacheKey(index) {
|
|
156
|
+
let key = ''
|
|
157
|
+
for (let i = index; i < this.#globStrings.length; i++) {
|
|
158
|
+
key += this.#globStrings[i]
|
|
159
|
+
if (i !== this.#globStrings.length - 1) {
|
|
160
|
+
key += '/'
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
return key
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
// Node's, but for `exclude`: given each path's absolute path (where Node gives its Dirent with
|
|
168
|
+
// `withFileTypes`), and in #addSubpattern, the path from the root (where Node's lstat takes it, as
|
|
169
|
+
// spelled from the root, from the process's cwd).
|
|
170
|
+
class Glob {
|
|
171
|
+
#root
|
|
172
|
+
#exclude
|
|
173
|
+
#cache
|
|
174
|
+
#results = new Set()
|
|
175
|
+
#queue = []
|
|
176
|
+
#subpatterns = new Map()
|
|
177
|
+
#patterns
|
|
178
|
+
|
|
179
|
+
constructor(host, pattern, { cwd, exclude }) {
|
|
180
|
+
this.#root = cwd
|
|
181
|
+
this.#exclude = exclude
|
|
182
|
+
this.#cache = new Cache(host)
|
|
183
|
+
const matcher = createMatcher(pattern)
|
|
184
|
+
this.#patterns = matcher.set.map((set, i) => new Pattern(set, matcher.globParts[i], new Set().add(0), new Set()))
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
globSync() {
|
|
188
|
+
this.#queue.push({ path: '.', patterns: this.#patterns })
|
|
189
|
+
while (this.#queue.length > 0) {
|
|
190
|
+
const item = this.#queue.pop()
|
|
191
|
+
for (let i = 0; i < item.patterns.length; i++) {
|
|
192
|
+
this.#addSubpatterns(item.path, item.patterns[i])
|
|
193
|
+
}
|
|
194
|
+
this.#subpatterns.forEach((patterns, path) => this.#queue.push({ path, patterns }))
|
|
195
|
+
this.#subpatterns.clear()
|
|
196
|
+
}
|
|
197
|
+
return [...this.#results]
|
|
198
|
+
}
|
|
199
|
+
#isDirectorySync(stat, pattern) {
|
|
200
|
+
if (stat?.isDirectory()) {
|
|
201
|
+
return true
|
|
202
|
+
}
|
|
203
|
+
if (!stat?.isSymbolicLink()) {
|
|
204
|
+
return false
|
|
205
|
+
}
|
|
206
|
+
return pattern.hasSeenSymlinks
|
|
207
|
+
}
|
|
208
|
+
#addSubpattern(path, pattern) {
|
|
209
|
+
if (this.#exclude) {
|
|
210
|
+
const fullpath = resolve(this.#root, path)
|
|
211
|
+
if (this.#cache.statSync(fullpath) !== null && this.#exclude(fullpath)) {
|
|
212
|
+
return
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
if (!this.#subpatterns.has(path)) {
|
|
216
|
+
this.#subpatterns.set(path, [pattern])
|
|
217
|
+
} else {
|
|
218
|
+
this.#subpatterns.get(path).push(pattern)
|
|
219
|
+
}
|
|
220
|
+
}
|
|
221
|
+
#addSubpatterns(path, pattern) {
|
|
222
|
+
const seen = this.#cache.add(path, pattern)
|
|
223
|
+
if (seen) {
|
|
224
|
+
return
|
|
225
|
+
}
|
|
226
|
+
const fullpath = resolve(this.#root, path)
|
|
227
|
+
const stat = this.#cache.statSync(fullpath)
|
|
228
|
+
const last = pattern.last
|
|
229
|
+
const isDirectory = this.#isDirectorySync(stat, pattern)
|
|
230
|
+
const isLast = pattern.isLast(isDirectory)
|
|
231
|
+
const isFirst = pattern.isFirst()
|
|
232
|
+
|
|
233
|
+
if (isFirst && pattern.at(0) === '') {
|
|
234
|
+
// Absolute path, go to root
|
|
235
|
+
this.#addSubpattern('/', pattern.child(new Set().add(1)))
|
|
236
|
+
return
|
|
237
|
+
}
|
|
238
|
+
if (isFirst && pattern.at(0) === '..') {
|
|
239
|
+
// Start with .., go to parent
|
|
240
|
+
this.#addSubpattern('../', pattern.child(new Set().add(1)))
|
|
241
|
+
return
|
|
242
|
+
}
|
|
243
|
+
if (isFirst && pattern.at(0) === '.') {
|
|
244
|
+
// Start with ., proceed
|
|
245
|
+
this.#addSubpattern('.', pattern.child(new Set().add(1)))
|
|
246
|
+
return
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
if (isLast && typeof pattern.at(-1) === 'string') {
|
|
250
|
+
// Add result if it exists
|
|
251
|
+
const p = pattern.at(-1)
|
|
252
|
+
const found = this.#cache.statSync(join(fullpath, p))
|
|
253
|
+
if (found && (p || isDirectory)) {
|
|
254
|
+
this.#results.add(join(path, p))
|
|
255
|
+
}
|
|
256
|
+
if (pattern.indexes.size === 1 && pattern.indexes.has(last)) {
|
|
257
|
+
return
|
|
258
|
+
}
|
|
259
|
+
} else if (isLast && pattern.at(-1) === lazyMinimatch().GLOBSTAR &&
|
|
260
|
+
(path !== '.' || pattern.at(0) === '.' || (last === 0 && stat))) {
|
|
261
|
+
// If pattern ends with **, add to results
|
|
262
|
+
// if path is ".", add it only if pattern starts with "." or pattern is exactly "**"
|
|
263
|
+
this.#results.add(path)
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
if (!isDirectory) {
|
|
267
|
+
return
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
let children
|
|
271
|
+
const firstPattern = pattern.indexes.size === 1 && pattern.at(pattern.indexes.values().next().value)
|
|
272
|
+
if (typeof firstPattern === 'string') {
|
|
273
|
+
const child = this.#cache.statSync(join(fullpath, firstPattern))
|
|
274
|
+
if (child) {
|
|
275
|
+
child.name = firstPattern
|
|
276
|
+
children = [child]
|
|
277
|
+
} else {
|
|
278
|
+
return
|
|
279
|
+
}
|
|
280
|
+
} else {
|
|
281
|
+
children = this.#cache.readdirSync(fullpath)
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
for (let i = 0; i < children.length; i++) {
|
|
285
|
+
const entry = children[i]
|
|
286
|
+
const entryPath = join(path, entry.name)
|
|
287
|
+
const entryFullpath = join(fullpath, entry.name)
|
|
288
|
+
this.#cache.addToStatCache(entryFullpath, entry)
|
|
289
|
+
const entryIsDirectory = entry.isDirectory()
|
|
290
|
+
|
|
291
|
+
const subPatterns = new Set()
|
|
292
|
+
const nSymlinks = new Set()
|
|
293
|
+
for (const index of pattern.indexes) {
|
|
294
|
+
// For each child, check potential patterns
|
|
295
|
+
const current = pattern.at(index)
|
|
296
|
+
const nextIndex = index + 1
|
|
297
|
+
const next = pattern.at(nextIndex)
|
|
298
|
+
const fromSymlink = pattern.symlinks.has(index)
|
|
299
|
+
|
|
300
|
+
if (current === lazyMinimatch().GLOBSTAR) {
|
|
301
|
+
const isDot = entry.name[0] === '.'
|
|
302
|
+
const nextMatches = pattern.test(nextIndex, entry.name)
|
|
303
|
+
|
|
304
|
+
let nextNonGlobIndex = nextIndex
|
|
305
|
+
while (pattern.at(nextNonGlobIndex) === lazyMinimatch().GLOBSTAR) {
|
|
306
|
+
nextNonGlobIndex++
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
const matchesDot = isDot && pattern.test(nextNonGlobIndex, entry.name)
|
|
310
|
+
|
|
311
|
+
if ((isDot && !matchesDot) ||
|
|
312
|
+
(this.#exclude && this.#exclude(entryFullpath))) {
|
|
313
|
+
continue
|
|
314
|
+
}
|
|
315
|
+
if (!fromSymlink && entryIsDirectory) {
|
|
316
|
+
// If directory, add ** to its potential patterns
|
|
317
|
+
subPatterns.add(index)
|
|
318
|
+
} else if (!fromSymlink && index === last) {
|
|
319
|
+
// If ** is last, add to results
|
|
320
|
+
this.#results.add(entryPath)
|
|
321
|
+
}
|
|
322
|
+
|
|
323
|
+
// Any pattern after ** is also a potential pattern
|
|
324
|
+
// so we can already test it here
|
|
325
|
+
if (nextMatches && nextIndex === last && !isLast) {
|
|
326
|
+
// If next pattern is the last one, add to results
|
|
327
|
+
this.#results.add(entryPath)
|
|
328
|
+
} else if (nextMatches && entryIsDirectory) {
|
|
329
|
+
// Pattern matched, meaning two patterns forward
|
|
330
|
+
// are also potential patterns
|
|
331
|
+
// e.g **/b/c when entry is a/b - add c to potential patterns
|
|
332
|
+
subPatterns.add(index + 2)
|
|
333
|
+
}
|
|
334
|
+
if ((nextMatches || pattern.at(0) === '.') &&
|
|
335
|
+
entryIsDirectory && !fromSymlink) {
|
|
336
|
+
// If pattern after ** matches, or pattern starts with "."
|
|
337
|
+
// and entry is a directory, add to potential patterns
|
|
338
|
+
subPatterns.add(nextIndex)
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
if (entry.isSymbolicLink()) {
|
|
342
|
+
nSymlinks.add(index)
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
if (next === '..' && entryIsDirectory) {
|
|
346
|
+
// In case pattern is "**/..",
|
|
347
|
+
// both parent and current directory should be added to the queue
|
|
348
|
+
// if this is the last pattern, add to results instead
|
|
349
|
+
const parent = join(path, '..')
|
|
350
|
+
if (nextIndex < last) {
|
|
351
|
+
if (!this.#subpatterns.has(path) && !this.#cache.seen(path, pattern, nextIndex + 1)) {
|
|
352
|
+
this.#subpatterns.set(path, [pattern.child(new Set().add(nextIndex + 1))])
|
|
353
|
+
}
|
|
354
|
+
if (!this.#subpatterns.has(parent) && !this.#cache.seen(parent, pattern, nextIndex + 1)) {
|
|
355
|
+
this.#subpatterns.set(parent, [pattern.child(new Set().add(nextIndex + 1))])
|
|
356
|
+
}
|
|
357
|
+
} else {
|
|
358
|
+
if (!this.#cache.seen(path, pattern, nextIndex)) {
|
|
359
|
+
this.#cache.add(path, pattern.child(new Set().add(nextIndex)))
|
|
360
|
+
this.#results.add(path)
|
|
361
|
+
}
|
|
362
|
+
if (!this.#cache.seen(path, pattern, nextIndex) || !this.#cache.seen(parent, pattern, nextIndex)) {
|
|
363
|
+
this.#cache.add(parent, pattern.child(new Set().add(nextIndex)))
|
|
364
|
+
this.#results.add(parent)
|
|
365
|
+
}
|
|
366
|
+
}
|
|
367
|
+
}
|
|
368
|
+
}
|
|
369
|
+
if (typeof current === 'string') {
|
|
370
|
+
if (pattern.test(index, entry.name) && index !== last) {
|
|
371
|
+
// If current pattern matches entry name
|
|
372
|
+
// the next pattern is a potential pattern
|
|
373
|
+
subPatterns.add(nextIndex)
|
|
374
|
+
} else if (current === '.' && pattern.test(nextIndex, entry.name)) {
|
|
375
|
+
// If current pattern is ".", proceed to test next pattern
|
|
376
|
+
if (nextIndex === last) {
|
|
377
|
+
this.#results.add(entryPath)
|
|
378
|
+
} else {
|
|
379
|
+
subPatterns.add(nextIndex + 1)
|
|
380
|
+
}
|
|
381
|
+
}
|
|
382
|
+
}
|
|
383
|
+
if (typeof current === 'object' && pattern.test(index, entry.name)) {
|
|
384
|
+
// If current pattern is a regex that matches entry name (e.g *.js)
|
|
385
|
+
// add next pattern to potential patterns, or to results if it's the last pattern
|
|
386
|
+
if (index === last) {
|
|
387
|
+
this.#results.add(entryPath)
|
|
388
|
+
} else if (entryIsDirectory) {
|
|
389
|
+
subPatterns.add(nextIndex)
|
|
390
|
+
}
|
|
391
|
+
}
|
|
392
|
+
}
|
|
393
|
+
if (subPatterns.size > 0) {
|
|
394
|
+
// If there are potential patterns, add to queue
|
|
395
|
+
this.#addSubpattern(entryPath, pattern.child(subPatterns, nSymlinks))
|
|
396
|
+
}
|
|
397
|
+
}
|
|
398
|
+
}
|
|
399
|
+
}
|
|
400
|
+
|
|
401
|
+
// fs.globSync(pattern, { cwd, exclude }) over `host`, `cwd` an absolute path there: the matches as
|
|
402
|
+
// Node spells them, from `cwd` (or from `/`, of an absolute pattern), never walking into a path
|
|
403
|
+
// `exclude` takes, given its absolute path. As Node's, it leaves out such a path where its `**`
|
|
404
|
+
// meets it alone: one the segment after the `**` matches is still a match.
|
|
405
|
+
export const globSync = (host, pattern, { cwd, exclude } = {}) => new Glob(host, pattern, { cwd, exclude }).globSync()
|
|
406
|
+
|
|
407
|
+
// As Node's matchGlobPattern keeps them: the most recent 250 patterns' matchers.
|
|
408
|
+
const MATCHERS_KEPT = 250
|
|
409
|
+
const matchers = new Map()
|
|
410
|
+
|
|
411
|
+
// path.matchesGlob(path, pattern), never folding case.
|
|
412
|
+
export function matchesGlob(path, pattern) {
|
|
413
|
+
let matcher = matchers.get(pattern)
|
|
414
|
+
if (matcher === undefined) {
|
|
415
|
+
matcher = createMatcher(pattern)
|
|
416
|
+
matchers.set(pattern, matcher)
|
|
417
|
+
if (matchers.size >= MATCHERS_KEPT) matchers.delete(matchers.keys().next().value)
|
|
418
|
+
}
|
|
419
|
+
return matcher.match(path)
|
|
420
|
+
}
|