banhaten 0.3.0 → 0.5.0

package/src/cli/package-plan.js

@@ -1,185 +1,185 @@
-import {
-  findPackageDependencies,
-  reconcileDependencyRange,
-} from "./package-version.js"
-
-const DEPENDENCY_SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-]
-
-export function createPackageDependencyPlan(packageJson, changes) {
-  if (!packageJson || typeof packageJson !== "object" || Array.isArray(packageJson)) {
-    throw new Error("package.json root must be an object.")
-  }
-  validatePackageDependencySections(packageJson)
-  const requirements = collectPackageRequirements(changes)
-  const operations = []
-
-  for (const requirement of requirements.values()) {
-    const declarations = findPackageDependencies(packageJson, requirement.name)
-
-    if (declarations.length === 0) {
-      operations.push({
-        kind: "add",
-        name: requirement.name,
-        range: requirement.range,
-        section: requirement.section,
-      })
-      continue
-    }
-
-    for (const declaration of declarations) {
-      const resolution = reconcileDependencyRange(
-        declaration.version,
-        requirement.range
-      )
-      assertDependencyResolution(
-        requirement.name,
-        declaration,
-        requirement.range,
-        resolution
-      )
-
-      if (resolution.status === "strengthened") {
-        operations.push({
-          kind: "strengthen",
-          name: requirement.name,
-          range: resolution.range,
-          section: declaration.section,
-        })
-      }
-    }
-  }
-
-  return {
-    operations,
-    requirements: [...requirements.values()],
-  }
-}
-
-export function applyPackageDependencyPlan(packageJson, operations) {
-  const touchedSections = new Set()
-
-  for (const operation of operations) {
-    const dependencies = packageJson[operation.section] || {}
-    dependencies[operation.name] = operation.range
-    packageJson[operation.section] = dependencies
-    touchedSections.add(operation.section)
-  }
-
-  for (const section of touchedSections) {
-    packageJson[section] = sortObject(packageJson[section])
-  }
-}
-
-export function mergeDependencyRequirements(target, incoming, source) {
-  for (const [name, range] of Object.entries(incoming)) {
-    if (!Object.hasOwn(target, name)) {
-      target[name] = range
-      continue
-    }
-
-    const resolution = reconcileDependencyRange(target[name], range)
-    if (resolution.status === "satisfied") continue
-    if (resolution.status === "strengthened") {
-      target[name] = resolution.range
-      continue
-    }
-
-    throw new Error(
-      `${source} declares dependency "${name}" as "${range}", which cannot be combined safely with "${target[name]}".`
-    )
-  }
-}
-
-function collectPackageRequirements(changes) {
-  const requirements = new Map()
-
-  for (const section of ["dependencies", "devDependencies"]) {
-    for (const [name, range] of Object.entries(changes[section] || {})) {
-      const validation = reconcileDependencyRange(range, range)
-      if (validation.status === "invalid-required") {
-        throw new Error(
-          `Banhaten declares an invalid semantic version range for "${name}": "${range}".`
-        )
-      }
-
-      const current = requirements.get(name)
-      if (!current) {
-        requirements.set(name, { name, range, section })
-        continue
-      }
-
-      if (section === "dependencies") current.section = section
-
-      const resolution = reconcileDependencyRange(current.range, range)
-      if (resolution.status === "satisfied") continue
-      if (resolution.status === "strengthened") {
-        current.range = resolution.range
-        continue
-      }
-
-      throw new Error(
-        `Banhaten registry dependency conflict for "${name}": ` +
-          `"${current.range}" and "${range}" cannot be combined safely.`
-      )
-    }
-  }
-
-  return requirements
-}
-
-function validatePackageDependencySections(packageJson) {
-  for (const section of DEPENDENCY_SECTIONS) {
-    const dependencies = packageJson[section]
-    if (
-      dependencies !== undefined &&
-      (!dependencies ||
-        typeof dependencies !== "object" ||
-        Array.isArray(dependencies))
-    ) {
-      throw new Error(`package.json ${section} must be an object.`)
-    }
-  }
-}
-
-function assertDependencyResolution(name, declaration, requiredRange, resolution) {
-  if (resolution.status === "satisfied" || resolution.status === "strengthened") {
-    return
-  }
-
-  if (resolution.status === "unsupported") {
-    throw new Error(
-      `dependency version conflict for "${name}": ${declaration.section} declares unsupported non-semver spec ` +
-        `"${declaration.version}", but Banhaten requires "${requiredRange}".`
-    )
-  }
-
-  if (resolution.status === "partial-overlap") {
-    throw new Error(
-      `dependency range conflict for "${name}": ${declaration.section} declares "${declaration.version}", ` +
-        `which only partially overlaps Banhaten's required "${requiredRange}". ` +
-        "Declare a range contained by both requirements."
-    )
-  }
-
-  if (resolution.status === "invalid-required") {
-    throw new Error(
-      `Banhaten declares an invalid semantic version range for "${name}": "${requiredRange}".`
-    )
-  }
-
-  throw new Error(
-    `dependency version conflict for "${name}": ${declaration.section} declares "${declaration.version}", ` +
-      `but Banhaten requires "${requiredRange}".`
-  )
-}
-
-function sortObject(value) {
-  return Object.fromEntries(
-    Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
-  )
-}
+import {
+  findPackageDependencies,
+  reconcileDependencyRange,
+} from "./package-version.js"
+
+const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+]
+
+export function createPackageDependencyPlan(packageJson, changes) {
+  if (!packageJson || typeof packageJson !== "object" || Array.isArray(packageJson)) {
+    throw new Error("package.json root must be an object.")
+  }
+  validatePackageDependencySections(packageJson)
+  const requirements = collectPackageRequirements(changes)
+  const operations = []
+
+  for (const requirement of requirements.values()) {
+    const declarations = findPackageDependencies(packageJson, requirement.name)
+
+    if (declarations.length === 0) {
+      operations.push({
+        kind: "add",
+        name: requirement.name,
+        range: requirement.range,
+        section: requirement.section,
+      })
+      continue
+    }
+
+    for (const declaration of declarations) {
+      const resolution = reconcileDependencyRange(
+        declaration.version,
+        requirement.range
+      )
+      assertDependencyResolution(
+        requirement.name,
+        declaration,
+        requirement.range,
+        resolution
+      )
+
+      if (resolution.status === "strengthened") {
+        operations.push({
+          kind: "strengthen",
+          name: requirement.name,
+          range: resolution.range,
+          section: declaration.section,
+        })
+      }
+    }
+  }
+
+  return {
+    operations,
+    requirements: [...requirements.values()],
+  }
+}
+
+export function applyPackageDependencyPlan(packageJson, operations) {
+  const touchedSections = new Set()
+
+  for (const operation of operations) {
+    const dependencies = packageJson[operation.section] || {}
+    dependencies[operation.name] = operation.range
+    packageJson[operation.section] = dependencies
+    touchedSections.add(operation.section)
+  }
+
+  for (const section of touchedSections) {
+    packageJson[section] = sortObject(packageJson[section])
+  }
+}
+
+export function mergeDependencyRequirements(target, incoming, source) {
+  for (const [name, range] of Object.entries(incoming)) {
+    if (!Object.hasOwn(target, name)) {
+      target[name] = range
+      continue
+    }
+
+    const resolution = reconcileDependencyRange(target[name], range)
+    if (resolution.status === "satisfied") continue
+    if (resolution.status === "strengthened") {
+      target[name] = resolution.range
+      continue
+    }
+
+    throw new Error(
+      `${source} declares dependency "${name}" as "${range}", which cannot be combined safely with "${target[name]}".`
+    )
+  }
+}
+
+function collectPackageRequirements(changes) {
+  const requirements = new Map()
+
+  for (const section of ["dependencies", "devDependencies"]) {
+    for (const [name, range] of Object.entries(changes[section] || {})) {
+      const validation = reconcileDependencyRange(range, range)
+      if (validation.status === "invalid-required") {
+        throw new Error(
+          `Banhaten declares an invalid semantic version range for "${name}": "${range}".`
+        )
+      }
+
+      const current = requirements.get(name)
+      if (!current) {
+        requirements.set(name, { name, range, section })
+        continue
+      }
+
+      if (section === "dependencies") current.section = section
+
+      const resolution = reconcileDependencyRange(current.range, range)
+      if (resolution.status === "satisfied") continue
+      if (resolution.status === "strengthened") {
+        current.range = resolution.range
+        continue
+      }
+
+      throw new Error(
+        `Banhaten registry dependency conflict for "${name}": ` +
+          `"${current.range}" and "${range}" cannot be combined safely.`
+      )
+    }
+  }
+
+  return requirements
+}
+
+function validatePackageDependencySections(packageJson) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const dependencies = packageJson[section]
+    if (
+      dependencies !== undefined &&
+      (!dependencies ||
+        typeof dependencies !== "object" ||
+        Array.isArray(dependencies))
+    ) {
+      throw new Error(`package.json ${section} must be an object.`)
+    }
+  }
+}
+
+function assertDependencyResolution(name, declaration, requiredRange, resolution) {
+  if (resolution.status === "satisfied" || resolution.status === "strengthened") {
+    return
+  }
+
+  if (resolution.status === "unsupported") {
+    throw new Error(
+      `dependency version conflict for "${name}": ${declaration.section} declares unsupported non-semver spec ` +
+        `"${declaration.version}", but Banhaten requires "${requiredRange}".`
+    )
+  }
+
+  if (resolution.status === "partial-overlap") {
+    throw new Error(
+      `dependency range conflict for "${name}": ${declaration.section} declares "${declaration.version}", ` +
+        `which only partially overlaps Banhaten's required "${requiredRange}". ` +
+        "Declare a range contained by both requirements."
+    )
+  }
+
+  if (resolution.status === "invalid-required") {
+    throw new Error(
+      `Banhaten declares an invalid semantic version range for "${name}": "${requiredRange}".`
+    )
+  }
+
+  throw new Error(
+    `dependency version conflict for "${name}": ${declaration.section} declares "${declaration.version}", ` +
+      `but Banhaten requires "${requiredRange}".`
+  )
+}
+
+function sortObject(value) {
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+  )
+}

package/src/cli/package-version.js

@@ -1,97 +1,97 @@
-import semver from "semver"
-
-const DEPENDENCY_SECTIONS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-]
-
-export function findPackageDependencies(packageJson, name) {
-  const declarations = []
-
-  for (const section of DEPENDENCY_SECTIONS) {
-    const dependencies = packageJson[section]
-    if (
-      dependencies &&
-      typeof dependencies === "object" &&
-      !Array.isArray(dependencies) &&
-      Object.hasOwn(dependencies, name)
-    ) {
-      declarations.push({
-        section,
-        version: dependencies[name],
-      })
-    }
-  }
-
-  return declarations
-}
-
-export function reconcileDependencyRange(declaredRange, requiredRange) {
-  const required = parseRange(requiredRange)
-  if (required.status !== "valid") {
-    return {
-      status: "invalid-required",
-      range: requiredRange,
-    }
-  }
-
-  const declared = parseRange(declaredRange)
-  if (declared.status === "invalid") {
-    return {
-      status: "unsupported",
-      range: declaredRange,
-    }
-  }
-  if (declared.status === "empty") {
-    return {
-      status: "conflict",
-      range: declaredRange,
-    }
-  }
-
-  if (semver.subset(declared.range, required.range)) {
-    return {
-      status: "satisfied",
-      range: declaredRange,
-    }
-  }
-
-  if (semver.subset(required.range, declared.range)) {
-    return {
-      status: "strengthened",
-      range: requiredRange.trim(),
-    }
-  }
-
-  if (semver.intersects(declared.range, required.range)) {
-    return {
-      status: "partial-overlap",
-      range: declaredRange,
-    }
-  }
-
-  return {
-    status: "conflict",
-    range: declaredRange,
-  }
-}
-
-export function dependencyVersionSatisfies(version, requiredRange) {
-  if (typeof version !== "string" || semver.valid(version) === null) return false
-  const required = parseRange(requiredRange)
-  if (required.status !== "valid") return false
-  return semver.satisfies(version, required.range)
-}
-
-function parseRange(value) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    return { status: "invalid" }
-  }
-  if (semver.validRange(value) === null) return { status: "invalid" }
-
-  const range = new semver.Range(value)
-  if (semver.minVersion(range) === null) return { status: "empty" }
-  return { range, status: "valid" }
-}
+import semver from "semver"
+
+const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+]
+
+export function findPackageDependencies(packageJson, name) {
+  const declarations = []
+
+  for (const section of DEPENDENCY_SECTIONS) {
+    const dependencies = packageJson[section]
+    if (
+      dependencies &&
+      typeof dependencies === "object" &&
+      !Array.isArray(dependencies) &&
+      Object.hasOwn(dependencies, name)
+    ) {
+      declarations.push({
+        section,
+        version: dependencies[name],
+      })
+    }
+  }
+
+  return declarations
+}
+
+export function reconcileDependencyRange(declaredRange, requiredRange) {
+  const required = parseRange(requiredRange)
+  if (required.status !== "valid") {
+    return {
+      status: "invalid-required",
+      range: requiredRange,
+    }
+  }
+
+  const declared = parseRange(declaredRange)
+  if (declared.status === "invalid") {
+    return {
+      status: "unsupported",
+      range: declaredRange,
+    }
+  }
+  if (declared.status === "empty") {
+    return {
+      status: "conflict",
+      range: declaredRange,
+    }
+  }
+
+  if (semver.subset(declared.range, required.range)) {
+    return {
+      status: "satisfied",
+      range: declaredRange,
+    }
+  }
+
+  if (semver.subset(required.range, declared.range)) {
+    return {
+      status: "strengthened",
+      range: requiredRange.trim(),
+    }
+  }
+
+  if (semver.intersects(declared.range, required.range)) {
+    return {
+      status: "partial-overlap",
+      range: declaredRange,
+    }
+  }
+
+  return {
+    status: "conflict",
+    range: declaredRange,
+  }
+}
+
+export function dependencyVersionSatisfies(version, requiredRange) {
+  if (typeof version !== "string" || semver.valid(version) === null) return false
+  const required = parseRange(requiredRange)
+  if (required.status !== "valid") return false
+  return semver.satisfies(version, required.range)
+}
+
+function parseRange(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return { status: "invalid" }
+  }
+  if (semver.validRange(value) === null) return { status: "invalid" }
+
+  const range = new semver.Range(value)
+  if (semver.minVersion(range) === null) return { status: "empty" }
+  return { range, status: "valid" }
+}