banhaten 0.4.0 → 0.5.0

package/src/cli/package-install-state.js

@@ -1,254 +1,254 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-
-import { inspectPackageManagerContext } from "./package-manager.js"
-import {
-  dependencyVersionSatisfies,
-  findPackageDependencies,
-} from "./package-version.js"
-
-const DEPENDENCY_SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-]
-
-export async function inspectPackageInstallState({
-  cwd,
-  packageJson,
-  requirements,
-}) {
-  const managerState = await inspectPackageManagerContext(cwd)
-  const { context } = managerState
-  const installedPackages = new Map()
-
-  for (const requirement of requirements) {
-    const installed = await findInstalledPackage(
-      cwd,
-      context.root,
-      requirement.name
-    )
-    if (
-      !installed ||
-      !dependencyVersionSatisfies(installed.version, requirement.range)
-    ) {
-      return { evidence: [], required: true }
-    }
-    installedPackages.set(requirement.name, installed)
-  }
-
-  if (!context.lockfilePath) {
-    return {
-      evidence: createCleanEvidence(managerState, installedPackages),
-      required: false,
-    }
-  }
-
-  if (context.manager !== "npm") {
-    return { evidence: [], required: true }
-  }
-
-  const lockEvidence = await readJsonEvidence(context.lockfilePath)
-  if (!lockEvidence) return { evidence: [], required: true }
-
-  const lockState = inspectNpmLock({
-    cwd,
-    lock: lockEvidence.value,
-    lockRoot: context.root,
-    packageJson,
-    requirements,
-  })
-  if (!lockState.compatible) return { evidence: [], required: true }
-
-  for (const [name, installed] of installedPackages) {
-    if (installed.version !== lockState.lockedVersions.get(name)) {
-      return { evidence: [], required: true }
-    }
-  }
-
-  return {
-    evidence: createCleanEvidence(
-      managerState,
-      installedPackages,
-      [lockEvidence]
-    ),
-    required: false,
-  }
-}
-
-function createCleanEvidence(
-  managerState,
-  installedPackages,
-  extra = []
-) {
-  return [
-    ...managerState.evidence,
-    ...extra,
-    ...[...installedPackages.values()].map(toEvidence),
-  ]
-}
-
-export function inspectNpmLock({
-  cwd,
-  lock,
-  lockRoot,
-  packageJson,
-  requirements,
-}) {
-  if (
-    !lock ||
-    typeof lock !== "object" ||
-    Array.isArray(lock) ||
-    ![2, 3].includes(lock.lockfileVersion) ||
-    !lock.packages ||
-    typeof lock.packages !== "object" ||
-    Array.isArray(lock.packages)
-  ) {
-    return { compatible: false, lockedVersions: new Map() }
-  }
-
-  const importerKey = path.relative(lockRoot, cwd).replaceAll("\\", "/")
-  const importer = lock.packages[importerKey]
-  if (!importer || typeof importer !== "object" || Array.isArray(importer)) {
-    return { compatible: false, lockedVersions: new Map() }
-  }
-
-  for (const section of DEPENDENCY_SECTIONS) {
-    if (!dependencySectionMatches(packageJson[section], importer[section])) {
-      return { compatible: false, lockedVersions: new Map() }
-    }
-  }
-
-  const lockedVersions = new Map()
-  for (const requirement of requirements) {
-    const lockedVersion = findModernLockedVersion(
-      lock.packages,
-      importerKey,
-      requirement.name
-    )
-    const declarations = findPackageDependencies(packageJson, requirement.name)
-    if (
-      !dependencyVersionSatisfies(lockedVersion, requirement.range) ||
-      declarations.length === 0 ||
-      declarations.some(
-        ({ version }) => !dependencyVersionSatisfies(lockedVersion, version)
-      )
-    ) {
-      return { compatible: false, lockedVersions: new Map() }
-    }
-    lockedVersions.set(requirement.name, lockedVersion)
-  }
-
-  return { compatible: true, lockedVersions }
-}
-
-function dependencySectionMatches(manifestSection, lockSection) {
-  const manifest = normalizeDependencySection(manifestSection)
-  const locked = normalizeDependencySection(lockSection)
-  if (!manifest || !locked) return false
-  const manifestEntries = Object.entries(manifest)
-  const lockedEntries = Object.entries(locked)
-
-  return manifestEntries.length === lockedEntries.length &&
-    manifestEntries.every(([name, range]) => locked[name] === range)
-}
-
-function normalizeDependencySection(value) {
-  if (value === undefined) return {}
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? value
-    : null
-}
-
-function findModernLockedVersion(packages, importerKey, name) {
-  let directory = importerKey
-
-  while (true) {
-    const prefix = directory ? `${directory}/` : ""
-    const entryKey = `${prefix}node_modules/${name}`
-    if (Object.hasOwn(packages, entryKey)) {
-      const entry = packages[entryKey]
-      return entry && typeof entry.version === "string" && !entry.link
-        ? entry.version
-        : null
-    }
-
-    if (!directory) return null
-    const parent = path.posix.dirname(directory)
-    directory = parent === "." ? "" : parent
-  }
-}
-
-async function findInstalledPackage(cwd, projectRoot, name) {
-  for (const nodeModulesPath of nodeModulesSearchPaths(cwd, projectRoot)) {
-    const manifestPath = path.join(
-      nodeModulesPath,
-      ...name.split("/"),
-      "package.json"
-    )
-
-    try {
-      const source = await fs.readFile(manifestPath)
-      const manifest = JSON.parse(source.toString("utf8"))
-      if (manifest.name === name && typeof manifest.version === "string") {
-        return { path: manifestPath, source, version: manifest.version }
-      }
-      return null
-    } catch (error) {
-      if (error.code === "ENOENT") continue
-      if (error instanceof SyntaxError) return null
-      throw error
-    }
-  }
-
-  return null
-}
-
-function nodeModulesSearchPaths(cwd, projectRoot) {
-  const paths = []
-  const boundary = path.resolve(projectRoot)
-  let directory = path.resolve(cwd)
-
-  while (true) {
-    paths.push(path.join(directory, "node_modules"))
-    if (directory === boundary) return paths
-
-    const parent = path.dirname(directory)
-    if (parent === directory || !isWithin(parent, boundary)) return paths
-    directory = parent
-  }
-}
-
-function isWithin(directory, boundary) {
-  const relative = path.relative(boundary, directory)
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
-}
-
-async function readJsonEvidence(filePath) {
-  const evidence = await readFileEvidence(filePath)
-  if (!evidence) return null
-
-  try {
-    return {
-      ...evidence,
-      value: JSON.parse(evidence.source.toString("utf8")),
-    }
-  } catch (error) {
-    if (error instanceof SyntaxError) return null
-    throw error
-  }
-}
-
-async function readFileEvidence(filePath) {
-  try {
-    return { path: filePath, source: await fs.readFile(filePath) }
-  } catch (error) {
-    if (error.code === "ENOENT") return null
-    throw error
-  }
-}
-
-function toEvidence({ path: evidencePath, source }) {
-  return { path: evidencePath, source }
-}
+import fs from "node:fs/promises"
+import path from "node:path"
+
+import { inspectPackageManagerContext } from "./package-manager.js"
+import {
+  dependencyVersionSatisfies,
+  findPackageDependencies,
+} from "./package-version.js"
+
+const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+]
+
+export async function inspectPackageInstallState({
+  cwd,
+  packageJson,
+  requirements,
+}) {
+  const managerState = await inspectPackageManagerContext(cwd)
+  const { context } = managerState
+  const installedPackages = new Map()
+
+  for (const requirement of requirements) {
+    const installed = await findInstalledPackage(
+      cwd,
+      context.root,
+      requirement.name
+    )
+    if (
+      !installed ||
+      !dependencyVersionSatisfies(installed.version, requirement.range)
+    ) {
+      return { evidence: [], required: true }
+    }
+    installedPackages.set(requirement.name, installed)
+  }
+
+  if (!context.lockfilePath) {
+    return {
+      evidence: createCleanEvidence(managerState, installedPackages),
+      required: false,
+    }
+  }
+
+  if (context.manager !== "npm") {
+    return { evidence: [], required: true }
+  }
+
+  const lockEvidence = await readJsonEvidence(context.lockfilePath)
+  if (!lockEvidence) return { evidence: [], required: true }
+
+  const lockState = inspectNpmLock({
+    cwd,
+    lock: lockEvidence.value,
+    lockRoot: context.root,
+    packageJson,
+    requirements,
+  })
+  if (!lockState.compatible) return { evidence: [], required: true }
+
+  for (const [name, installed] of installedPackages) {
+    if (installed.version !== lockState.lockedVersions.get(name)) {
+      return { evidence: [], required: true }
+    }
+  }
+
+  return {
+    evidence: createCleanEvidence(
+      managerState,
+      installedPackages,
+      [lockEvidence]
+    ),
+    required: false,
+  }
+}
+
+function createCleanEvidence(
+  managerState,
+  installedPackages,
+  extra = []
+) {
+  return [
+    ...managerState.evidence,
+    ...extra,
+    ...[...installedPackages.values()].map(toEvidence),
+  ]
+}
+
+export function inspectNpmLock({
+  cwd,
+  lock,
+  lockRoot,
+  packageJson,
+  requirements,
+}) {
+  if (
+    !lock ||
+    typeof lock !== "object" ||
+    Array.isArray(lock) ||
+    ![2, 3].includes(lock.lockfileVersion) ||
+    !lock.packages ||
+    typeof lock.packages !== "object" ||
+    Array.isArray(lock.packages)
+  ) {
+    return { compatible: false, lockedVersions: new Map() }
+  }
+
+  const importerKey = path.relative(lockRoot, cwd).replaceAll("\\", "/")
+  const importer = lock.packages[importerKey]
+  if (!importer || typeof importer !== "object" || Array.isArray(importer)) {
+    return { compatible: false, lockedVersions: new Map() }
+  }
+
+  for (const section of DEPENDENCY_SECTIONS) {
+    if (!dependencySectionMatches(packageJson[section], importer[section])) {
+      return { compatible: false, lockedVersions: new Map() }
+    }
+  }
+
+  const lockedVersions = new Map()
+  for (const requirement of requirements) {
+    const lockedVersion = findModernLockedVersion(
+      lock.packages,
+      importerKey,
+      requirement.name
+    )
+    const declarations = findPackageDependencies(packageJson, requirement.name)
+    if (
+      !dependencyVersionSatisfies(lockedVersion, requirement.range) ||
+      declarations.length === 0 ||
+      declarations.some(
+        ({ version }) => !dependencyVersionSatisfies(lockedVersion, version)
+      )
+    ) {
+      return { compatible: false, lockedVersions: new Map() }
+    }
+    lockedVersions.set(requirement.name, lockedVersion)
+  }
+
+  return { compatible: true, lockedVersions }
+}
+
+function dependencySectionMatches(manifestSection, lockSection) {
+  const manifest = normalizeDependencySection(manifestSection)
+  const locked = normalizeDependencySection(lockSection)
+  if (!manifest || !locked) return false
+  const manifestEntries = Object.entries(manifest)
+  const lockedEntries = Object.entries(locked)
+
+  return manifestEntries.length === lockedEntries.length &&
+    manifestEntries.every(([name, range]) => locked[name] === range)
+}
+
+function normalizeDependencySection(value) {
+  if (value === undefined) return {}
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null
+}
+
+function findModernLockedVersion(packages, importerKey, name) {
+  let directory = importerKey
+
+  while (true) {
+    const prefix = directory ? `${directory}/` : ""
+    const entryKey = `${prefix}node_modules/${name}`
+    if (Object.hasOwn(packages, entryKey)) {
+      const entry = packages[entryKey]
+      return entry && typeof entry.version === "string" && !entry.link
+        ? entry.version
+        : null
+    }
+
+    if (!directory) return null
+    const parent = path.posix.dirname(directory)
+    directory = parent === "." ? "" : parent
+  }
+}
+
+async function findInstalledPackage(cwd, projectRoot, name) {
+  for (const nodeModulesPath of nodeModulesSearchPaths(cwd, projectRoot)) {
+    const manifestPath = path.join(
+      nodeModulesPath,
+      ...name.split("/"),
+      "package.json"
+    )
+
+    try {
+      const source = await fs.readFile(manifestPath)
+      const manifest = JSON.parse(source.toString("utf8"))
+      if (manifest.name === name && typeof manifest.version === "string") {
+        return { path: manifestPath, source, version: manifest.version }
+      }
+      return null
+    } catch (error) {
+      if (error.code === "ENOENT") continue
+      if (error instanceof SyntaxError) return null
+      throw error
+    }
+  }
+
+  return null
+}
+
+function nodeModulesSearchPaths(cwd, projectRoot) {
+  const paths = []
+  const boundary = path.resolve(projectRoot)
+  let directory = path.resolve(cwd)
+
+  while (true) {
+    paths.push(path.join(directory, "node_modules"))
+    if (directory === boundary) return paths
+
+    const parent = path.dirname(directory)
+    if (parent === directory || !isWithin(parent, boundary)) return paths
+    directory = parent
+  }
+}
+
+function isWithin(directory, boundary) {
+  const relative = path.relative(boundary, directory)
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))
+}
+
+async function readJsonEvidence(filePath) {
+  const evidence = await readFileEvidence(filePath)
+  if (!evidence) return null
+
+  try {
+    return {
+      ...evidence,
+      value: JSON.parse(evidence.source.toString("utf8")),
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) return null
+    throw error
+  }
+}
+
+async function readFileEvidence(filePath) {
+  try {
+    return { path: filePath, source: await fs.readFile(filePath) }
+  } catch (error) {
+    if (error.code === "ENOENT") return null
+    throw error
+  }
+}
+
+function toEvidence({ path: evidencePath, source }) {
+  return { path: evidencePath, source }
+}