@yanglaofish/fishtools 0.5.2 → 0.5.3

package/node_modules/@npmcli/arborist/lib/patch.js

@@ -1,111 +0,0 @@
-// Native dependency patching helpers shared across build-ideal-tree and reify.
-// Patches are plain unified diffs (git apply-compatible) applied with jsdiff using a fuzz factor of 0 so that any context drift fails loudly.
-const { applyPatch, parsePatch } = require('diff')
-const ssri = require('ssri')
-const fs = require('node:fs')
-const { promises: fsp } = fs
-const { resolve, relative, dirname, isAbsolute } = require('node:path')
-
-// Compute the SSRI integrity of a patch file's contents.
-// Accepts a string or Buffer and returns a sha512 SSRI string.
-const patchIntegrity = data =>
-  ssri.fromData(Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8'), {
-    algorithms: ['sha512'],
-  }).toString()
-
-// Strip a leading git-style "a/" or "b/" prefix from a diff path.
-const stripPrefix = file => file.replace(/^[ab]\//, '')
-
-// True when a diff path points at /dev/null, signalling a file add or delete.
-const isDevNull = file => !file || file === '/dev/null' || /(^|\/)\.dev\/null$/.test(file)
-
-const patchError = (message, code, file) =>
-  Object.assign(new Error(message), { code, file })
-
-// Resolve a diff path under cwd and refuse anything that escapes the package directory.
-const containedTarget = (cwd, file) => {
-  const target = resolve(cwd, file)
-  const rel = relative(cwd, target)
-  if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
-    throw patchError(`patch path escapes the package directory: ${file}`, 'EPATCHUNSAFE', file)
-  }
-  return target
-}
-
-// Run a parsed file patch against a source string with fuzz 0.
-// Returns the patched text, or throws EPATCHFAILED on any context mismatch.
-const strictApply = (source, filePatch, file) => {
-  const patched = applyPatch(source, filePatch, { fuzzFactor: 0 })
-  if (patched === false) {
-    throw patchError(`patch could not be applied to ${file}`, 'EPATCHFAILED', file)
-  }
-  return patched
-}
-
-// Apply a single parsed file patch under cwd.
-// Handles modified, added (--- /dev/null) and deleted (+++ /dev/null) files.
-const applyFilePatch = async (filePatch, cwd) => {
-  const isAdd = isDevNull(filePatch.oldFileName)
-  const isDelete = isDevNull(filePatch.newFileName)
-
-  if (isDelete) {
-    const file = stripPrefix(filePatch.oldFileName)
-    const target = containedTarget(cwd, file)
-    // verify the file still matches the diff before removing it
-    const source = await fsp.readFile(target, 'utf8').catch(() => {
-      throw patchError(`patch target to delete is missing: ${file}`, 'EPATCHFAILED', file)
-    })
-    strictApply(source, filePatch, file)
-    await fsp.rm(target, { force: true })
-    return
-  }
-
-  const file = stripPrefix(filePatch.newFileName)
-  const target = containedTarget(cwd, file)
-
-  if (isAdd) {
-    // a new file must not already exist, otherwise the tarball drifted
-    if (fs.existsSync(target)) {
-      throw patchError(`patch adds a file that already exists: ${file}`, 'EPATCHFAILED', file)
-    }
-    const created = strictApply('', filePatch, file)
-    await fsp.mkdir(dirname(target), { recursive: true })
-    await fsp.writeFile(target, created)
-    return
-  }
-
-  const source = await fsp.readFile(target, 'utf8').catch(() => {
-    throw patchError(`patch target is missing: ${file}`, 'EPATCHFAILED', file)
-  })
-  const mode = (await fsp.stat(target)).mode
-  const patched = strictApply(source, filePatch, file)
-  await fsp.writeFile(target, patched)
-  await fsp.chmod(target, mode)
-}
-
-// Apply a unified diff to the package extracted at `cwd`.
-// `patch` is the raw diff contents (string or Buffer).
-// Throws with code EPATCHFAILED on any hunk or file that cannot be applied.
-const applyPatchToDir = async ({ patch, cwd }) => {
-  const filePatches = parsePatch(patch.toString('utf8'))
-  for (const filePatch of filePatches) {
-    // jsdiff emits an empty trailing patch for some inputs; skip those.
-    if (!filePatch.hunks.length && isDevNull(filePatch.oldFileName) && isDevNull(filePatch.newFileName)) {
-      continue
-    }
-    try {
-      await applyFilePatch(filePatch, cwd)
-    } catch (er) {
-      // re-code raw filesystem errors so a patch failure is never mistaken for an optional-install skip
-      if (typeof er?.code === 'string' && er.code.startsWith('EPATCH')) {
-        throw er
-      }
-      throw Object.assign(new Error(`failed to apply patch: ${er.message}`), { code: 'EPATCHFAILED', cause: er })
-    }
-  }
-}
-
-module.exports = {
-  applyPatchToDir,
-  patchIntegrity,
-}

package/node_modules/@npmcli/arborist/lib/patched-dependencies.js

@@ -1,168 +0,0 @@
-// Resolve the root patchedDependencies map against an ideal tree.
-// Attaches node.patched = { path, integrity } to each matched node.
-// Enforces the failure modes (workspace-member entry, missing file, unused patch, non-registry target, ambiguous selectors) as hard errors.
-const semver = require('semver')
-const npa = require('npm-package-arg')
-const { log } = require('proc-log')
-const { resolve, relative, isAbsolute } = require('node:path')
-const { readFile } = require('node:fs/promises')
-const { patchIntegrity } = require('./patch.js')
-
-// Split a selector key into { name, spec }. spec is null for a name-only key.
-const parseSelector = key => {
-  const at = key.indexOf('@', 1)
-  return at === -1
-    ? { name: key, spec: null }
-    : { name: key.slice(0, at), spec: key.slice(at + 1) }
-}
-
-const err = (message, code, extra = {}) =>
-  Object.assign(new Error(message), { code, ...extra })
-
-// Pick the most specific range among several that all match a version.
-// Returns the strict subset, or throws when ordering is ambiguous.
-// semver.subset is transitive, so the running minimum is a subset of every range it did not throw on.
-const pickRange = (ranges, name, version) => {
-  let best = ranges[0]
-  for (const r of ranges.slice(1)) {
-    if (semver.subset(r.spec, best.spec, { loose: true })) {
-      best = r
-    } else if (!semver.subset(best.spec, r.spec, { loose: true })) {
-      throw err(
-        `Ambiguous patch selectors for ${name}@${version}: ` +
-          `"${name}@${best.spec}" and "${name}@${r.spec}" overlap but neither ` +
-          `is a subset. Add an exact "${name}@${version}" entry to disambiguate.`,
-        'EPATCHAMBIGUOUS'
-      )
-    }
-  }
-  return best
-}
-
-// Choose the winning selector for a node: exact > range subset > name-only.
-const matchSelector = (selectors, node) => {
-  const { name, version } = node
-  const matches = selectors.filter(s => s.name === name)
-  if (!matches.length) {
-    return null
-  }
-
-  const exact = matches.find(s =>
-    s.spec && semver.valid(s.spec) && semver.eq(s.spec, version, { loose: true }))
-  if (exact) {
-    return exact
-  }
-
-  const ranges = matches.filter(s =>
-    s.spec && !semver.valid(s.spec) && semver.satisfies(version, s.spec, { loose: true }))
-  if (ranges.length) {
-    return pickRange(ranges, name, version)
-  }
-
-  return matches.find(s => s.spec === null) || null
-}
-
-const resolvePatchedDependencies = async (tree, { path, allowUnusedPatches, rm }) => {
-  const patchedDependencies = tree.package?.patchedDependencies || {}
-  const selectors = Object.entries(patchedDependencies)
-    .map(([key, patchPath]) => ({ ...parseSelector(key), key, patchPath }))
-
-  // cache patch file integrity by path so shared diffs are read once
-  const integrityCache = new Map()
-  const readPatch = async patchPath => {
-    if (integrityCache.has(patchPath)) {
-      return integrityCache.get(patchPath)
-    }
-    // patch files must live inside the project so the patch set stays auditable
-    const abs = resolve(path, patchPath)
-    const rel = relative(path, abs)
-    if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
-      throw err(`patch path escapes the project: ${patchPath}`, 'EPATCHUNSAFE', { path: patchPath })
-    }
-    let contents
-    try {
-      contents = await readFile(abs)
-    } catch {
-      throw err(`patch file not found: ${patchPath}`, 'EPATCHNOTFOUND', { path: patchPath })
-    }
-    const integrity = patchIntegrity(contents)
-    integrityCache.set(patchPath, integrity)
-    return integrity
-  }
-
-  const usedKeys = new Set()
-  for (const node of tree.inventory.values()) {
-    // patchedDependencies is honoured only in the root manifest
-    if (node.isWorkspace) {
-      // Link.package already delegates to its target's package
-      const pkg = node.package
-      if (pkg?.patchedDependencies && Object.keys(pkg.patchedDependencies).length) {
-        throw err(
-          `patchedDependencies is only supported in the root package.json, ` +
-            `but was found in workspace "${node.name}". Move the entry to the root.`,
-          'EPATCHWORKSPACE',
-          { workspace: node.name }
-        )
-      }
-      continue
-    }
-    if (node.isProjectRoot) {
-      continue
-    }
-
-    const selector = matchSelector(selectors, node)
-    if (!selector) {
-      // a node that was patched but no longer matches a selector must be re-extracted to revert its files
-      if (node.patched) {
-        node.patchRemoved = true
-      }
-      node.patched = null
-      continue
-    }
-
-    // a non-registry consumer edge (file:, git:, http(s)) means there is no registry tarball to patch; npm: aliases stay registry.
-    // checking edges (not isRegistryDependency) avoids rejecting an edgeless node, which is still a registry dep.
-    if ([...node.edgesIn].some(e => e.spec && !npa(e.spec).registry)) {
-      throw err(
-        `Cannot patch non-registry dependency ${node.name}@${node.version} ` +
-          `(selector "${selector.key}"). Only registry dependencies can be patched.`,
-        'EPATCHNONREGISTRY',
-        { node: node.name }
-      )
-    }
-
-    const integrity = await readPatch(selector.patchPath)
-    node.patched = { path: selector.patchPath, integrity }
-    usedKeys.add(selector.key)
-  }
-
-  if (selectors.length) {
-    const unused = selectors.filter(s => !usedKeys.has(s.key))
-
-    // an explicit `npm uninstall <name>` orphans that package's patch entry, so drop it instead of failing
-    const removed = new Set(rm)
-    const dropped = unused.filter(s => removed.has(s.name))
-    if (dropped.length) {
-      const patched = { ...tree.package.patchedDependencies }
-      for (const s of dropped) {
-        delete patched[s.key]
-        log.notice('patch', `Removing patch entry "${s.key}" for uninstalled ${s.name}; left ${s.patchPath} in place.`)
-      }
-      // undefined drops the key entirely when reify writes package.json
-      tree.package.patchedDependencies = Object.keys(patched).length ? patched : undefined
-    }
-
-    const stillUnused = unused.filter(s => !removed.has(s.name))
-    if (stillUnused.length && !allowUnusedPatches) {
-      throw err(
-        `The following patches were registered but matched no installed ` +
-          `package:\n${stillUnused.map(s => `  ${s.key} -> ${s.patchPath}`).join('\n')}\n` +
-          `Use --allow-unused-patches to install anyway.`,
-        'EPATCHUNUSED',
-        { unused: stillUnused.map(s => s.key) }
-      )
-    }
-  }
-}
-
-module.exports = { resolvePatchedDependencies, matchSelector, parseSelector }

package/node_modules/cacache/lib/util/cache-dir.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const fs = require('fs/promises')
-const path = require('path')
-
-const tagContent = `Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by cacache.
-# For information about cache directory tags, see https://bford.info/cachedir/
-`
-
-async function mkdir (cache) {
-  await fs.mkdir(cache, { recursive: true, owner: 'inherit' })
-  await writeTag(cache)
-}
-
-async function writeTag (cache) {
-  try {
-    await fs.writeFile(path.join(cache, 'CACHEDIR.TAG'), tagContent, { flag: 'wx' })
-  } catch (err) {
-    if (err.code !== 'EEXIST') {
-      throw err
-    }
-  }
-}
-
-module.exports = {
-  mkdir,
-  tagContent,
-}

package/node_modules/diff/CONTRIBUTING.md

@@ -1,28 +0,0 @@
-## Building and testing
-
-```
-yarn
-yarn test
-```
-
-To run tests in a *browser* (for instance to test compatibility with Firefox, with Safari, or with old browser versions), run `yarn karma start`, then open http://localhost:9876/ in the browser you want to test in. Results of the test run will appear in the terminal where `yarn karma start` is running.
-
-If you notice any problems, please report them to the GitHub issue tracker at
-[http://github.com/kpdecker/jsdiff/issues](http://github.com/kpdecker/jsdiff/issues).
-
-## Releasing
-
-Run a test in Firefox via the procedure above before releasing.
-
-A full release may be completed by first updating the `"version"` property in package.json, then running the following:
-
-```
-yarn clean
-yarn build
-yarn npm publish
-```
-
-After releasing, remember to:
-* commit the `package.json` change and push it to GitHub
-* create a new version tag on GitHub
-* update `diff.js` on the `gh-pages` branch to the latest built version from the `dist/` folder.

package/node_modules/diff/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2009-2015, Kevin Decker <kpdecker@gmail.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.