@packall/core 0.1.0 → 0.2.0

package/src/input-file.ts

@@ -13,102 +13,111 @@
  * A lockfile is checked for first, because `package-lock.json` and
  * `package.json` are both JSON objects and only the content tells them apart.
  */
-import * as Effect from "effect/Effect"
-import * as FileSystem from "effect/FileSystem"
-import * as Option from "effect/Option"
-import { parseDependencyTarget } from "./dependency-range.js"
-import { InputFileKind } from "./enums/input-file-kind.js"
-import type { LockfileFormat } from "./enums/lockfile-format.js"
-import type { InvalidSpecError, LockfileError } from "./errors.js"
-import { InvalidInputFileError } from "./errors.js"
-import { detectLockfile } from "./lockfile/detect.js"
-import { parseLockfile } from "./lockfile/parse.js"
-import type { LockedTree } from "./lockfile/types.js"
-import type { PackageJson } from "./schemas/package-json.js"
-import { decodePackageJson } from "./schemas/package-json.js"
-import type { PackageSpec } from "./spec.js"
-import { parseSpecs } from "./spec.js"
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+
+import { parseDependencyTarget } from "./dependency-range.js";
+import { InputFileKind } from "./enums/input-file-kind.js";
+import type { LockfileFormat } from "./enums/lockfile-format.js";
+import type { InvalidSpecError, LockfileError } from "./errors.js";
+import { InvalidInputFileError } from "./errors.js";
+import { detectLockfile } from "./lockfile/detect.js";
+import { parseLockfile } from "./lockfile/parse.js";
+import type { LockedTree } from "./lockfile/types.js";
+import type { PackageJson } from "./schemas/package-json.js";
+import { decodePackageJson } from "./schemas/package-json.js";
+import type { PackageSpec } from "./spec.js";
+import { parseSpecs } from "./spec.js";
 
 export type InputFileResult = {
-  readonly kind: InputFileKind
-  readonly specs: ReadonlyArray<PackageSpec>
-  /** Entries that were recognised but cannot be bundled from a registry. */
-  readonly warnings: ReadonlyArray<string>
-  /**
-   * The pinned graph, set only for a lockfile.
-   *
-   * `specs` carries the same roots for display, but a lockfile run must resolve
-   * from this — see `locked-resolve` for why re-resolving the roots' ranges
-   * would quietly produce a different bundle.
-   */
-  readonly lockfile?: LockedTree | undefined
-  /**
-   * Names from the blocks a package.json always installs — `dependencies` and,
-   * unless `--prod`, `devDependencies`.
-   *
-   * Used to check a lockfile against the manifest beside it. Deliberately
-   * excludes optional and peer entries: both are legitimately absent from a
-   * lockfile (an optional dependency that failed to build, a peer the consumer
-   * is expected to supply), so including them would turn a useful staleness
-   * check into a false alarm.
-   */
-  readonly required?: ReadonlyArray<string> | undefined
-}
+	readonly kind: InputFileKind;
+	readonly specs: ReadonlyArray<PackageSpec>;
+	/** Entries that were recognised but cannot be bundled from a registry. */
+	readonly warnings: ReadonlyArray<string>;
+	/**
+	 * The pinned graph, set only for a lockfile.
+	 *
+	 * `specs` carries the same roots for display, but a lockfile run must resolve
+	 * from this — see `locked-resolve` for why re-resolving the roots' ranges
+	 * would quietly produce a different bundle.
+	 */
+	readonly lockfile?: LockedTree | undefined;
+	/**
+	 * Names from the blocks a package.json always installs — `dependencies` and,
+	 * unless `--prod`, `devDependencies`.
+	 *
+	 * Used to check a lockfile against the manifest beside it. Deliberately
+	 * excludes optional and peer entries: both are legitimately absent from a
+	 * lockfile (an optional dependency that failed to build, a peer the consumer
+	 * is expected to supply), so including them would turn a useful staleness
+	 * check into a false alarm.
+	 */
+	readonly required?: ReadonlyArray<string> | undefined;
+};
 
 /** Which dependency blocks of a package.json become root specs. */
 export type InputFileOptions = {
-  /**
-   * Include `devDependencies`.
-   *
-   * On by default: if you are pointing this tool at a package.json, you are
-   * almost certainly trying to make that project installable behind the
-   * firewall, and a project without its dev tooling does not build. `--prod`
-   * turns it off.
-   */
-  readonly includeDev: boolean
-  /**
-   * For a lockfile, which workspace member's dependencies are the roots.
-   *
-   * Set when a package.json found its lockfile by walking up: the file then
-   * covers the whole repository, and only one member of it was asked for.
-   */
-  readonly importer?: string | undefined
-}
-
-export const defaultInputFileOptions: InputFileOptions = { includeDev: true }
+	/**
+	 * Include `devDependencies`.
+	 *
+	 * On by default: if you are pointing this tool at a package.json, you are
+	 * almost certainly trying to make that project installable behind the
+	 * firewall, and a project without its dev tooling does not build. `--prod`
+	 * turns it off.
+	 */
+	readonly includeDev: boolean;
+	/**
+	 * For a lockfile, which workspace member's dependencies are the roots.
+	 *
+	 * Set when a package.json found its lockfile by walking up: the file then
+	 * covers the whole repository, and only one member of it was asked for.
+	 */
+	readonly importer?: string | undefined;
+};
+
+export const defaultInputFileOptions: InputFileOptions = { includeDev: true };
 
 /** Reads and parses an input file. */
 export const readInputFile = (
-  filePath: string,
-  options: InputFileOptions = defaultInputFileOptions
+	filePath: string,
+	options: InputFileOptions = defaultInputFileOptions,
 ): Effect.Effect<InputFileResult, InvalidInputFileError | LockfileError, FileSystem.FileSystem> =>
-  Effect.gen(function*() {
-    const fs = yield* FileSystem.FileSystem
-
-    const exists = yield* fs.exists(filePath).pipe(
-      Effect.mapError((cause) => new InvalidInputFileError(filePath, "could not be read", { cause }))
-    )
-    if (!exists) {
-      return yield* Effect.fail(new InvalidInputFileError(filePath, "file does not exist"))
-    }
-
-    const content = yield* fs.readFileString(filePath).pipe(
-      Effect.mapError((cause) => new InvalidInputFileError(filePath, "could not be read", { cause }))
-    )
-
-    return yield* Effect.try({
-      try: () => parseInputFile(filePath, content, options),
-      catch: (error) =>
-        // A LockfileError already names the file and says what is wrong with
-        // it; wrapping it would only stutter.
-        error instanceof InvalidInputFileError || isLockfileError(error)
-          ? error
-          : new InvalidInputFileError(filePath, describeError(error), { cause: error })
-    })
-  })
+	Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+
+		const exists = yield* fs
+			.exists(filePath)
+			.pipe(
+				Effect.mapError(
+					(cause) => new InvalidInputFileError(filePath, "could not be read", { cause }),
+				),
+			);
+		if (!exists) {
+			return yield* Effect.fail(new InvalidInputFileError(filePath, "file does not exist"));
+		}
+
+		const content = yield* fs
+			.readFileString(filePath)
+			.pipe(
+				Effect.mapError(
+					(cause) => new InvalidInputFileError(filePath, "could not be read", { cause }),
+				),
+			);
+
+		return yield* Effect.try({
+			try: () => parseInputFile(filePath, content, options),
+			catch: (error) =>
+				// A LockfileError already names the file and says what is wrong with
+				// it; wrapping it would only stutter.
+				error instanceof InvalidInputFileError || isLockfileError(error)
+					? error
+					: new InvalidInputFileError(filePath, describeError(error), { cause: error }),
+		});
+	});
 
 const isLockfileError = (error: unknown): error is LockfileError =>
-  error instanceof Error && "_tag" in error && error._tag === "LockfileError"
+	error instanceof Error && "_tag" in error && error._tag === "LockfileError";
 
 /**
  * Parses file content that has already been read.
@@ -117,125 +126,125 @@ const isLockfileError = (error: unknown): error is LockfileError =>
  * strings and no file system at all.
  */
 export const parseInputFile = (
-  filePath: string,
-  content: string,
-  options: InputFileOptions = defaultInputFileOptions
+	filePath: string,
+	content: string,
+	options: InputFileOptions = defaultInputFileOptions,
 ): InputFileResult => {
-  const trimmed = content.trim()
-  if (trimmed.length === 0) {
-    throw new InvalidInputFileError(filePath, "file is empty")
-  }
-
-  // Checked first: a package-lock.json is also a JSON object whose top level
-  // looks a lot like a package.json, and reading one as the other would produce
-  // a bundle with none of the pinning that was asked for.
-  const detected = detectLockfile(trimmed)
-  if (detected._tag === "Unsupported") {
-    throw new InvalidInputFileError(filePath, `${detected.label} — ${detected.hint}`)
-  }
-  if (detected._tag === "Supported") {
-    return fromLockfile(filePath, content, detected.format, options)
-  }
-
-  return looksLikeJson(trimmed)
-    ? fromPackageJson(filePath, trimmed, options)
-    : fromList(filePath, content)
-}
-
-const looksLikeJson = (trimmed: string): boolean => trimmed.startsWith("{")
+	const trimmed = content.trim();
+	if (trimmed.length === 0) {
+		throw new InvalidInputFileError(filePath, "file is empty");
+	}
+
+	// Checked first: a package-lock.json is also a JSON object whose top level
+	// looks a lot like a package.json, and reading one as the other would produce
+	// a bundle with none of the pinning that was asked for.
+	const detected = detectLockfile(trimmed);
+	if (detected._tag === "Unsupported") {
+		throw new InvalidInputFileError(filePath, `${detected.label} — ${detected.hint}`);
+	}
+	if (detected._tag === "Supported") {
+		return fromLockfile(filePath, content, detected.format, options);
+	}
+
+	return looksLikeJson(trimmed)
+		? fromPackageJson(filePath, trimmed, options)
+		: fromList(filePath, content);
+};
+
+const looksLikeJson = (trimmed: string): boolean => trimmed.startsWith("{");
 
 /* -------------------------------------------------------------------------- */
 /* Lockfile                                                                   */
 /* -------------------------------------------------------------------------- */
 
 const fromLockfile = (
-  filePath: string,
-  content: string,
-  format: LockfileFormat,
-  options: InputFileOptions
+	filePath: string,
+	content: string,
+	format: LockfileFormat,
+	options: InputFileOptions,
 ): InputFileResult => {
-  const lockfile = parseLockfile(filePath, content, format, { importer: options.importer })
-
-  // The same devDependency rule as a package.json, applied to the pinned roots
-  // so that `specs` shows exactly what the run will bundle.
-  const roots = lockfile.roots.filter((root) => options.includeDev || root.kind !== "dev")
-
-  return {
-    kind: InputFileKind.Lockfile,
-    specs: roots.map((root) => ({
-      name: root.name,
-      selector: { _tag: "Exact", version: root.version },
-      raw: `${root.name}@${root.version}`
-    })),
-    warnings: lockfile.warnings,
-    lockfile
-  }
-}
+	const lockfile = parseLockfile(filePath, content, format, { importer: options.importer });
+
+	// The same devDependency rule as a package.json, applied to the pinned roots
+	// so that `specs` shows exactly what the run will bundle.
+	const roots = lockfile.roots.filter((root) => options.includeDev || root.kind !== "dev");
+
+	return {
+		kind: InputFileKind.Lockfile,
+		specs: roots.map((root) => ({
+			name: root.name,
+			selector: { _tag: "Exact", version: root.version },
+			raw: `${root.name}@${root.version}`,
+		})),
+		warnings: lockfile.warnings,
+		lockfile,
+	};
+};
 
 /* -------------------------------------------------------------------------- */
 /* package.json                                                               */
 /* -------------------------------------------------------------------------- */
 
 const fromPackageJson = (
-  filePath: string,
-  content: string,
-  options: InputFileOptions
+	filePath: string,
+	content: string,
+	options: InputFileOptions,
 ): InputFileResult => {
-  const parsed = parsePackageJson(filePath, content)
-
-  const specs: Array<PackageSpec> = []
-  const warnings: Array<string> = []
-  const required: Array<string> = []
-  const seen = new Set<string>()
-
-  const collect = (
-    entries: Record<string, string> | undefined,
-    label: string,
-    skip?: (name: string) => boolean
-  ): void => {
-    if (entries === undefined) return
-    for (const [name, raw] of Object.entries(entries)) {
-      if (skip?.(name)) continue
-      const target = parseDependencyTarget(name, raw)
-      if (target._tag === "Unsupported") {
-        warnings.push(
-          `${label}: skipped ${name}@${target.raw} (${target.reason}) — not fetchable from a registry`
-        )
-        continue
-      }
-      // `target.name` rather than the key, so an `npm:` alias is recorded under
-      // the name a lockfile would actually pin it as.
-      if (label === "dependencies" || label === "devDependencies") required.push(target.name)
-      const key = `${target.name}|${JSON.stringify(target.selector)}`
-      if (seen.has(key)) continue
-      seen.add(key)
-      specs.push({
-        name: target.name,
-        selector: target.selector,
-        raw: `${target.name}@${raw}`
-      })
-    }
-  }
-
-  collect(parsed.dependencies, "dependencies")
-  collect(parsed.optionalDependencies, "optionalDependencies")
-  if (options.includeDev) {
-    collect(parsed.devDependencies, "devDependencies")
-  }
-  const meta = parsed.peerDependenciesMeta ?? {}
-  collect(parsed.peerDependencies, "peerDependencies", (name) => meta[name]?.optional === true)
-
-  if (specs.length === 0) {
-    throw new InvalidInputFileError(
-      filePath,
-      options.includeDev
-        ? "package.json declares no dependencies to bundle"
-        : "package.json declares no non-dev dependencies to bundle (drop --prod to include devDependencies)"
-    )
-  }
-
-  return { kind: InputFileKind.PackageJson, specs, warnings, required }
-}
+	const parsed = parsePackageJson(filePath, content);
+
+	const specs: Array<PackageSpec> = [];
+	const warnings: Array<string> = [];
+	const required: Array<string> = [];
+	const seen = new Set<string>();
+
+	const collect = (
+		entries: Record<string, string> | undefined,
+		label: string,
+		skip?: (name: string) => boolean,
+	): void => {
+		if (entries === undefined) return;
+		for (const [name, raw] of Object.entries(entries)) {
+			if (skip?.(name)) continue;
+			const target = parseDependencyTarget(name, raw);
+			if (target._tag === "Unsupported") {
+				warnings.push(
+					`${label}: skipped ${name}@${target.raw} (${target.reason}) — not fetchable from a registry`,
+				);
+				continue;
+			}
+			// `target.name` rather than the key, so an `npm:` alias is recorded under
+			// the name a lockfile would actually pin it as.
+			if (label === "dependencies" || label === "devDependencies") required.push(target.name);
+			const key = `${target.name}|${JSON.stringify(target.selector)}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			specs.push({
+				name: target.name,
+				selector: target.selector,
+				raw: `${target.name}@${raw}`,
+			});
+		}
+	};
+
+	collect(parsed.dependencies, "dependencies");
+	collect(parsed.optionalDependencies, "optionalDependencies");
+	if (options.includeDev) {
+		collect(parsed.devDependencies, "devDependencies");
+	}
+	const meta = parsed.peerDependenciesMeta ?? {};
+	collect(parsed.peerDependencies, "peerDependencies", (name) => meta[name]?.optional === true);
+
+	if (specs.length === 0) {
+		throw new InvalidInputFileError(
+			filePath,
+			options.includeDev
+				? "package.json declares no dependencies to bundle"
+				: "package.json declares no non-dev dependencies to bundle (drop --prod to include devDependencies)",
+		);
+	}
+
+	return { kind: InputFileKind.PackageJson, specs, warnings, required };
+};
 
 /**
  * Reads a package.json, or gives up on its contents rather than on the run.
@@ -246,40 +255,43 @@ const fromPackageJson = (
  * dependencies to bundle", which is both true and more useful.
  */
 const parsePackageJson = (filePath: string, content: string): PackageJson => {
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(content)
-  } catch (error) {
-    throw new InvalidInputFileError(filePath, `not valid JSON — ${describeError(error)}`, {
-      cause: error
-    })
-  }
-
-  return Option.getOrElse(decodePackageJson(parsed), (): PackageJson => ({}))
-}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		throw new InvalidInputFileError(filePath, `not valid JSON — ${describeError(error)}`, {
+			cause: error,
+		});
+	}
+
+	return Option.getOrElse(decodePackageJson(parsed), (): PackageJson => ({}));
+};
 
 /* -------------------------------------------------------------------------- */
 /* Spec list                                                                  */
 /* -------------------------------------------------------------------------- */
 
 const fromList = (filePath: string, content: string): InputFileResult => {
-  const rawLines = content.split(/\r?\n/)
-  const lines = rawLines.flatMap((line) => {
-    const withoutComment = stripComment(line).trim()
-    return withoutComment.length === 0 ? [] : withoutComment
-  })
-
-  if (lines.length === 0) {
-    throw new InvalidInputFileError(filePath, "no package specs found (only blank lines and comments)")
-  }
-
-  const { specs, errors } = parseSpecs(lines)
-  if (errors.length > 0) {
-    throw new InvalidInputFileError(filePath, formatSpecErrors(errors, rawLines))
-  }
-
-  return { kind: InputFileKind.List, specs, warnings: [] }
-}
+	const rawLines = content.split(/\r?\n/);
+	const lines = rawLines.flatMap((line) => {
+		const withoutComment = stripComment(line).trim();
+		return withoutComment.length === 0 ? [] : withoutComment;
+	});
+
+	if (lines.length === 0) {
+		throw new InvalidInputFileError(
+			filePath,
+			"no package specs found (only blank lines and comments)",
+		);
+	}
+
+	const { specs, errors } = parseSpecs(lines);
+	if (errors.length > 0) {
+		throw new InvalidInputFileError(filePath, formatSpecErrors(errors, rawLines));
+	}
+
+	return { kind: InputFileKind.List, specs, warnings: [] };
+};
 
 /**
  * Strips `#` and `//` comments.
@@ -288,25 +300,25 @@ const fromList = (filePath: string, content: string): InputFileResult => {
  * `https://…` does not get silently truncated.
  */
 const stripComment = (line: string): string => {
-  const hash = line.indexOf("#")
-  const result = hash === -1 ? line : line.slice(0, hash)
-  const slashes = result.indexOf("//")
-  if (slashes === 0) return ""
-  if (slashes > 0 && result[slashes - 1] !== ":") return result.slice(0, slashes)
-  return result
-}
+	const hash = line.indexOf("#");
+	const result = hash === -1 ? line : line.slice(0, hash);
+	const slashes = result.indexOf("//");
+	if (slashes === 0) return "";
+	if (slashes > 0 && result[slashes - 1] !== ":") return result.slice(0, slashes);
+	return result;
+};
 
 const formatSpecErrors = (
-  errors: ReadonlyArray<InvalidSpecError>,
-  rawLines: ReadonlyArray<string>
+	errors: ReadonlyArray<InvalidSpecError>,
+	rawLines: ReadonlyArray<string>,
 ): string => {
-  const details = errors.map((error) => {
-    const index = rawLines.findIndex((line) => stripComment(line).trim() === error.spec)
-    const where = index === -1 ? "" : ` (line ${index + 1})`
-    return `    ${error.spec}${where}: ${error.reason}`
-  })
-  return `${errors.length} invalid spec(s):\n${details.join("\n")}`
-}
+	const details = errors.map((error) => {
+		const index = rawLines.findIndex((line) => stripComment(line).trim() === error.spec);
+		const where = index === -1 ? "" : ` (line ${index + 1})`;
+		return `    ${error.spec}${where}: ${error.reason}`;
+	});
+	return `${errors.length} invalid spec(s):\n${details.join("\n")}`;
+};
 
 const describeError = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error)
+	error instanceof Error ? error.message : String(error);