Deployed the page to Github Pages.
This commit is contained in:
parent
1d79754e93
commit
2c89899458
SSH key fingerprint:
SHA256:kEsnuHX+qbwhxSAXPUQ4ox535wFHu/hIRaa53FzxRpo
62797 changed files with 6551425 additions and 15279 deletions
456
node_modules/npm-packlist/lib/index.js
generated
vendored
Normal file
456
node_modules/npm-packlist/lib/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,456 @@
|
|||
'use strict'
|
||||
|
||||
const { Walker: IgnoreWalker } = require('ignore-walk')
|
||||
const { lstatSync: lstat, readFileSync: readFile } = require('fs')
|
||||
const { basename, dirname, extname, join, relative, resolve, sep } = require('path')
|
||||
|
||||
// symbols used to represent synthetic rule sets
|
||||
const defaultRules = Symbol('npm-packlist.rules.default')
|
||||
const strictRules = Symbol('npm-packlist.rules.strict')
|
||||
|
||||
// There may be others, but :?|<> are handled by node-tar
|
||||
const nameIsBadForWindows = file => /\*/.test(file)
|
||||
|
||||
// these are the default rules that are applied to everything except for non-link bundled deps
|
||||
const defaults = [
|
||||
'.npmignore',
|
||||
'.gitignore',
|
||||
'**/.git',
|
||||
'**/.svn',
|
||||
'**/.hg',
|
||||
'**/CVS',
|
||||
'**/.git/**',
|
||||
'**/.svn/**',
|
||||
'**/.hg/**',
|
||||
'**/CVS/**',
|
||||
'/.lock-wscript',
|
||||
'/.wafpickle-*',
|
||||
'/build/config.gypi',
|
||||
'npm-debug.log',
|
||||
'**/.npmrc',
|
||||
'.*.swp',
|
||||
'.DS_Store',
|
||||
'**/.DS_Store/**',
|
||||
'._*',
|
||||
'**/._*/**',
|
||||
'*.orig',
|
||||
'/archived-packages/**',
|
||||
]
|
||||
|
||||
const strictDefaults = [
|
||||
// these are forcibly excluded
|
||||
'/.git',
|
||||
]
|
||||
|
||||
const normalizePath = (path) => path.split('\\').join('/')
|
||||
|
||||
const readOutOfTreeIgnoreFiles = (root, rel, result = []) => {
|
||||
for (const file of ['.npmignore', '.gitignore']) {
|
||||
try {
|
||||
const ignoreContent = readFile(join(root, file), { encoding: 'utf8' })
|
||||
result.push(ignoreContent)
|
||||
// break the loop immediately after reading, this allows us to prioritize
|
||||
// the .npmignore and discard the .gitignore if one is present
|
||||
break
|
||||
} catch (err) {
|
||||
// we ignore ENOENT errors completely because we don't care if the file doesn't exist
|
||||
// but we throw everything else because failing to read a file that does exist is
|
||||
// something that the user likely wants to know about
|
||||
// istanbul ignore next -- we do not need to test a thrown error
|
||||
if (err.code !== 'ENOENT') {
|
||||
throw err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!rel) {
|
||||
return result
|
||||
}
|
||||
|
||||
const firstRel = rel.split(sep, 1)[0]
|
||||
const newRoot = join(root, firstRel)
|
||||
const newRel = relative(newRoot, join(root, rel))
|
||||
|
||||
return readOutOfTreeIgnoreFiles(newRoot, newRel, result)
|
||||
}
|
||||
|
||||
class PackWalker extends IgnoreWalker {
|
||||
constructor (tree, opts) {
|
||||
const options = {
|
||||
...opts,
|
||||
includeEmpty: false,
|
||||
follow: false,
|
||||
// we path.resolve() here because ignore-walk doesn't do it and we want full paths
|
||||
path: resolve(opts?.path || tree.path).replace(/\\/g, '/'),
|
||||
ignoreFiles: opts?.ignoreFiles || [
|
||||
defaultRules,
|
||||
'package.json',
|
||||
'.npmignore',
|
||||
'.gitignore',
|
||||
strictRules,
|
||||
],
|
||||
}
|
||||
|
||||
super(options)
|
||||
this.isPackage = options.isPackage
|
||||
this.seen = options.seen || new Set()
|
||||
this.tree = tree
|
||||
this.requiredFiles = options.requiredFiles || []
|
||||
|
||||
const additionalDefaults = []
|
||||
if (options.prefix && options.workspaces) {
|
||||
const path = normalizePath(options.path)
|
||||
const prefix = normalizePath(options.prefix)
|
||||
const workspaces = options.workspaces.map((ws) => normalizePath(ws))
|
||||
|
||||
// istanbul ignore else - this does nothing unless we need it to
|
||||
if (path !== prefix && workspaces.includes(path)) {
|
||||
// if path and prefix are not the same directory, and workspaces has path in it
|
||||
// then we know path is a workspace directory. in order to not drop ignore rules
|
||||
// from directories between the workspaces root (prefix) and the workspace itself
|
||||
// (path) we need to find and read those now
|
||||
const relpath = relative(options.prefix, dirname(options.path))
|
||||
additionalDefaults.push(...readOutOfTreeIgnoreFiles(options.prefix, relpath))
|
||||
} else if (path === prefix) {
|
||||
// on the other hand, if the path and prefix are the same, then we ignore workspaces
|
||||
// so that we don't pack a workspace as part of the root project. append them as
|
||||
// normalized relative paths from the root
|
||||
additionalDefaults.push(...workspaces.map((w) => normalizePath(relative(options.path, w))))
|
||||
}
|
||||
}
|
||||
|
||||
// go ahead and inject the default rules now
|
||||
this.injectRules(defaultRules, [...defaults, ...additionalDefaults])
|
||||
|
||||
if (!this.isPackage) {
|
||||
// if this instance is not a package, then place some strict default rules, and append
|
||||
// known required files for this directory
|
||||
this.injectRules(strictRules, [
|
||||
...strictDefaults,
|
||||
...this.requiredFiles.map((file) => `!${file}`),
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
// overridden method: we intercept the reading of the package.json file here so that we can
|
||||
// process it into both the package.json file rules as well as the strictRules synthetic rule set
|
||||
addIgnoreFile (file, callback) {
|
||||
// if we're adding anything other than package.json, then let ignore-walk handle it
|
||||
if (file !== 'package.json' || !this.isPackage) {
|
||||
return super.addIgnoreFile(file, callback)
|
||||
}
|
||||
|
||||
return this.processPackage(callback)
|
||||
}
|
||||
|
||||
// overridden method: if we're done, but we're a package, then we also need to evaluate bundles
|
||||
// before we actually emit our done event
|
||||
emit (ev, data) {
|
||||
if (ev !== 'done' || !this.isPackage) {
|
||||
return super.emit(ev, data)
|
||||
}
|
||||
|
||||
// we intentionally delay the done event while keeping the function sync here
|
||||
// eslint-disable-next-line promise/catch-or-return, promise/always-return
|
||||
this.gatherBundles().then(() => {
|
||||
super.emit('done', this.result)
|
||||
})
|
||||
return true
|
||||
}
|
||||
|
||||
// overridden method: before actually filtering, we make sure that we've removed the rules for
|
||||
// files that should no longer take effect due to our order of precedence
|
||||
filterEntries () {
|
||||
if (this.ignoreRules['package.json']) {
|
||||
// package.json means no .npmignore or .gitignore
|
||||
this.ignoreRules['.npmignore'] = null
|
||||
this.ignoreRules['.gitignore'] = null
|
||||
} else if (this.ignoreRules['.npmignore']) {
|
||||
// .npmignore means no .gitignore
|
||||
this.ignoreRules['.gitignore'] = null
|
||||
}
|
||||
|
||||
return super.filterEntries()
|
||||
}
|
||||
|
||||
// overridden method: we never want to include anything that isn't a file or directory
|
||||
onstat (opts, callback) {
|
||||
if (!opts.st.isFile() && !opts.st.isDirectory()) {
|
||||
return callback()
|
||||
}
|
||||
|
||||
return super.onstat(opts, callback)
|
||||
}
|
||||
|
||||
// overridden method: we want to refuse to pack files that are invalid, node-tar protects us from
|
||||
// a lot of them but not all
|
||||
stat (opts, callback) {
|
||||
if (nameIsBadForWindows(opts.entry)) {
|
||||
return callback()
|
||||
}
|
||||
|
||||
return super.stat(opts, callback)
|
||||
}
|
||||
|
||||
// overridden method: this is called to create options for a child walker when we step
|
||||
// in to a normal child directory (this will never be a bundle). the default method here
|
||||
// copies the root's `ignoreFiles` value, but we don't want to respect package.json for
|
||||
// subdirectories, so we override it with a list that intentionally omits package.json
|
||||
walkerOpt (entry, opts) {
|
||||
let ignoreFiles = null
|
||||
|
||||
// however, if we have a tree, and we have workspaces, and the directory we're about
|
||||
// to step into is a workspace, then we _do_ want to respect its package.json
|
||||
if (this.tree.workspaces) {
|
||||
const workspaceDirs = [...this.tree.workspaces.values()]
|
||||
.map((dir) => dir.replace(/\\/g, '/'))
|
||||
|
||||
const entryPath = join(this.path, entry).replace(/\\/g, '/')
|
||||
if (workspaceDirs.includes(entryPath)) {
|
||||
ignoreFiles = [
|
||||
defaultRules,
|
||||
'package.json',
|
||||
'.npmignore',
|
||||
'.gitignore',
|
||||
strictRules,
|
||||
]
|
||||
}
|
||||
} else {
|
||||
ignoreFiles = [
|
||||
defaultRules,
|
||||
'.npmignore',
|
||||
'.gitignore',
|
||||
strictRules,
|
||||
]
|
||||
}
|
||||
|
||||
return {
|
||||
...super.walkerOpt(entry, opts),
|
||||
ignoreFiles,
|
||||
// we map over our own requiredFiles and pass ones that are within this entry
|
||||
requiredFiles: this.requiredFiles
|
||||
.map((file) => {
|
||||
if (relative(file, entry) === '..') {
|
||||
return relative(entry, file).replace(/\\/g, '/')
|
||||
}
|
||||
return false
|
||||
})
|
||||
.filter(Boolean),
|
||||
}
|
||||
}
|
||||
|
||||
// overridden method: we want child walkers to be instances of this class, not ignore-walk
|
||||
walker (entry, opts, callback) {
|
||||
new PackWalker(this.tree, this.walkerOpt(entry, opts)).on('done', callback).start()
|
||||
}
|
||||
|
||||
// overridden method: we use a custom sort method to help compressibility
|
||||
sort (a, b) {
|
||||
// optimize for compressibility
|
||||
// extname, then basename, then locale alphabetically
|
||||
// https://twitter.com/isntitvacant/status/1131094910923231232
|
||||
const exta = extname(a).toLowerCase()
|
||||
const extb = extname(b).toLowerCase()
|
||||
const basea = basename(a).toLowerCase()
|
||||
const baseb = basename(b).toLowerCase()
|
||||
|
||||
return exta.localeCompare(extb, 'en') ||
|
||||
basea.localeCompare(baseb, 'en') ||
|
||||
a.localeCompare(b, 'en')
|
||||
}
|
||||
|
||||
// convenience method: this joins the given rules with newlines, appends a trailing newline,
|
||||
// and calls the internal onReadIgnoreFile method
|
||||
injectRules (filename, rules, callback = () => {}) {
|
||||
this.onReadIgnoreFile(filename, `${rules.join('\n')}\n`, callback)
|
||||
}
|
||||
|
||||
// custom method: this is called by addIgnoreFile when we find a package.json, it uses the
|
||||
// arborist tree to pull both default rules and strict rules for the package
|
||||
processPackage (callback) {
|
||||
const {
|
||||
bin,
|
||||
browser,
|
||||
files,
|
||||
main,
|
||||
} = this.tree.package
|
||||
|
||||
// rules in these arrays are inverted since they are patterns we want to _not_ ignore
|
||||
const ignores = []
|
||||
const strict = [
|
||||
...strictDefaults,
|
||||
'!/package.json',
|
||||
'!/readme{,.*[^~$]}',
|
||||
'!/copying{,.*[^~$]}',
|
||||
'!/license{,.*[^~$]}',
|
||||
'!/licence{,.*[^~$]}',
|
||||
'/.git',
|
||||
'/node_modules',
|
||||
'.npmrc',
|
||||
'/package-lock.json',
|
||||
'/yarn.lock',
|
||||
'/pnpm-lock.yaml',
|
||||
]
|
||||
|
||||
// if we have a files array in our package, we need to pull rules from it
|
||||
if (files) {
|
||||
for (let file of files) {
|
||||
// invert the rule because these are things we want to include
|
||||
if (file.startsWith('./')) {
|
||||
file = file.slice(1)
|
||||
}
|
||||
if (file.endsWith('/*')) {
|
||||
file += '*'
|
||||
}
|
||||
const inverse = `!${file}`
|
||||
try {
|
||||
// if an entry in the files array is a specific file, then we need to include it as a
|
||||
// strict requirement for this package. if it's a directory or a pattern, it's a default
|
||||
// pattern instead. this is ugly, but we have to stat to find out if it's a file
|
||||
const stat = lstat(join(this.path, file.replace(/^!+/, '')).replace(/\\/g, '/'))
|
||||
// if we have a file and we know that, it's strictly required
|
||||
if (stat.isFile()) {
|
||||
strict.unshift(inverse)
|
||||
this.requiredFiles.push(file.startsWith('/') ? file.slice(1) : file)
|
||||
} else if (stat.isDirectory()) {
|
||||
// otherwise, it's a default ignore, and since we got here we know it's not a pattern
|
||||
// so we include the directory contents
|
||||
ignores.push(inverse)
|
||||
ignores.push(`${inverse}/**`)
|
||||
}
|
||||
// if the thing exists, but is neither a file or a directory, we don't want it at all
|
||||
} catch (err) {
|
||||
// if lstat throws, then we assume we're looking at a pattern and treat it as a default
|
||||
ignores.push(inverse)
|
||||
}
|
||||
}
|
||||
|
||||
// we prepend a '*' to exclude everything, followed by our inverted file rules
|
||||
// which now mean to include those
|
||||
this.injectRules('package.json', ['*', ...ignores])
|
||||
}
|
||||
|
||||
// browser is required
|
||||
if (browser) {
|
||||
strict.push(`!/${browser}`)
|
||||
}
|
||||
|
||||
// main is required
|
||||
if (main) {
|
||||
strict.push(`!/${main}`)
|
||||
}
|
||||
|
||||
// each bin is required
|
||||
if (bin) {
|
||||
for (const key in bin) {
|
||||
strict.push(`!/${bin[key]}`)
|
||||
}
|
||||
}
|
||||
|
||||
// and now we add all of the strict rules to our synthetic file
|
||||
this.injectRules(strictRules, strict, callback)
|
||||
}
|
||||
|
||||
// custom method: after we've finished gathering the files for the root package, we call this
|
||||
// before emitting the 'done' event in order to gather all of the files for bundled deps
|
||||
async gatherBundles () {
|
||||
if (this.seen.has(this.tree)) {
|
||||
return
|
||||
}
|
||||
|
||||
// add this node to our seen tracker
|
||||
this.seen.add(this.tree)
|
||||
|
||||
// if we're the project root, then we look at our bundleDependencies, otherwise we got here
|
||||
// because we're a bundled dependency of the root, which means we need to include all prod
|
||||
// and optional dependencies in the bundle
|
||||
let toBundle
|
||||
if (this.tree.isProjectRoot) {
|
||||
const { bundleDependencies } = this.tree.package
|
||||
toBundle = bundleDependencies || []
|
||||
} else {
|
||||
const { dependencies, optionalDependencies } = this.tree.package
|
||||
toBundle = Object.keys(dependencies || {}).concat(Object.keys(optionalDependencies || {}))
|
||||
}
|
||||
|
||||
for (const dep of toBundle) {
|
||||
const edge = this.tree.edgesOut.get(dep)
|
||||
// no edgeOut = missing node, so skip it. we can't pack it if it's not here
|
||||
// we also refuse to pack peer dependencies and dev dependencies
|
||||
if (!edge || edge.peer || edge.dev) {
|
||||
continue
|
||||
}
|
||||
|
||||
// get a reference to the node we're bundling
|
||||
const node = this.tree.edgesOut.get(dep).to
|
||||
// if there's no node, this is most likely an optional dependency that hasn't been
|
||||
// installed. just skip it.
|
||||
if (!node) {
|
||||
continue
|
||||
}
|
||||
// we use node.path for the path because we want the location the node was linked to,
|
||||
// not where it actually lives on disk
|
||||
const path = node.path
|
||||
// but link nodes don't have edgesOut, so we need to pass in the target of the node
|
||||
// in order to make sure we correctly traverse its dependencies
|
||||
const tree = node.target
|
||||
|
||||
// and start building options to be passed to the walker for this package
|
||||
const walkerOpts = {
|
||||
path,
|
||||
isPackage: true,
|
||||
ignoreFiles: [],
|
||||
seen: this.seen, // pass through seen so we can prevent infinite circular loops
|
||||
}
|
||||
|
||||
// if our node is a link, we apply defaultRules. we don't do this for regular bundled
|
||||
// deps because their .npmignore and .gitignore files are excluded by default and may
|
||||
// override defaults
|
||||
if (node.isLink) {
|
||||
walkerOpts.ignoreFiles.push(defaultRules)
|
||||
}
|
||||
|
||||
// _all_ nodes will follow package.json rules from their package root
|
||||
walkerOpts.ignoreFiles.push('package.json')
|
||||
|
||||
// only link nodes will obey .npmignore or .gitignore
|
||||
if (node.isLink) {
|
||||
walkerOpts.ignoreFiles.push('.npmignore')
|
||||
walkerOpts.ignoreFiles.push('.gitignore')
|
||||
}
|
||||
|
||||
// _all_ nodes follow strict rules
|
||||
walkerOpts.ignoreFiles.push(strictRules)
|
||||
|
||||
// create a walker for this dependency and gather its results
|
||||
const walker = new PackWalker(tree, walkerOpts)
|
||||
const bundled = await new Promise((pResolve, pReject) => {
|
||||
walker.on('error', pReject)
|
||||
walker.on('done', pResolve)
|
||||
walker.start()
|
||||
})
|
||||
|
||||
// now we make sure we have our paths correct from the root, and accumulate everything into
|
||||
// our own result set to deduplicate
|
||||
const relativeFrom = relative(this.root, walker.path)
|
||||
for (const file of bundled) {
|
||||
this.result.add(join(relativeFrom, file).replace(/\\/g, '/'))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const walk = (tree, options, callback) => {
|
||||
if (typeof options === 'function') {
|
||||
callback = options
|
||||
options = {}
|
||||
}
|
||||
const p = new Promise((pResolve, pReject) => {
|
||||
new PackWalker(tree, { ...options, isPackage: true })
|
||||
.on('done', pResolve).on('error', pReject).start()
|
||||
})
|
||||
return callback ? p.then(res => callback(null, res), callback) : p
|
||||
}
|
||||
|
||||
module.exports = walk
|
||||
walk.Walker = PackWalker
|
||||
Loading…
Add table
Add a link
Reference in a new issue