@packall/core 0.1.0 → 0.2.0

package/src/schemas/lenient.ts

@@ -13,11 +13,12 @@
  * fails the whole record over one numeric value, where the wire format wants
  * that entry skipped and its neighbours kept.
  */
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Schema from "effect/Schema"
-import * as Getter from "effect/SchemaGetter"
-import { isRecord } from "../utils/is-record.js"
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Getter from "effect/SchemaGetter";
+
+import { isRecord } from "../utils/is-record.js";
 
 /**
  * An optional field that goes *absent* rather than failing when it is
@@ -28,11 +29,11 @@ import { isRecord } from "../utils/is-record.js"
  * costs the platform filter one signal; it should not cost the run the package.
  */
 export const tolerant = <S extends Schema.Top>(schema: S) =>
-  Schema.optional(
-    Schema.UndefinedOr(schema).pipe(
-      Schema.catchDecoding(() => Effect.succeed(Option.some(undefined)))
-    )
-  )
+	Schema.optional(
+		Schema.UndefinedOr(schema).pipe(
+			Schema.catchDecoding(() => Effect.succeed(Option.some(undefined))),
+		),
+	);
 
 /**
  * Keeps only the string-valued members of an untyped object.
@@ -42,26 +43,27 @@ export const tolerant = <S extends Schema.Top>(schema: S) =>
  * a dependency block is no reason to forget the others.
  */
 export const StringRecordSchema = Schema.Record(Schema.String, Schema.Unknown).pipe(
-  Schema.decodeTo(Schema.Record(Schema.String, Schema.String), {
-    decode: Getter.transform((raw: Record<string, unknown>) => {
-      const out: Record<string, string> = {}
-      for (const [key, value] of Object.entries(raw)) {
-        if (typeof value === "string") out[key] = value
-      }
-      return out
-    }),
-    encode: Getter.passthroughSubtype()
-  })
-)
+	Schema.decodeTo(Schema.Record(Schema.String, Schema.String), {
+		decode: Getter.transform((raw: Record<string, unknown>) => {
+			const out: Record<string, string> = {};
+			for (const [key, value] of Object.entries(raw)) {
+				if (typeof value === "string") out[key] = value;
+			}
+			return out;
+		}),
+		encode: Getter.passthroughSubtype(),
+	}),
+);
 
 /** The same per-entry tolerance for a list: `["linux", 7]` decodes to `["linux"]`. */
 export const StringArraySchema = Schema.Array(Schema.Unknown).pipe(
-  Schema.decodeTo(Schema.Array(Schema.String), {
-    decode: Getter.transform((raw: ReadonlyArray<unknown>) =>
-      raw.flatMap((entry) => (typeof entry === "string" ? entry : []))),
-    encode: Getter.passthroughSubtype()
-  })
-)
+	Schema.decodeTo(Schema.Array(Schema.String), {
+		decode: Getter.transform((raw: ReadonlyArray<unknown>) =>
+			raw.flatMap((entry) => (typeof entry === "string" ? entry : [])),
+		),
+		encode: Getter.passthroughSubtype(),
+	}),
+);
 
 /**
  * `peerDependenciesMeta`, normalised.
@@ -71,17 +73,17 @@ export const StringArraySchema = Schema.Array(Schema.Unknown).pipe(
  * value means "not optional".
  */
 export const OptionalFlagRecordSchema = Schema.Record(Schema.String, Schema.Unknown).pipe(
-  Schema.decodeTo(Schema.Record(Schema.String, Schema.Struct({ optional: Schema.Boolean })), {
-    decode: Getter.transform((raw: Record<string, unknown>) => {
-      const out: Record<string, { optional: boolean }> = {}
-      for (const [key, value] of Object.entries(raw)) {
-        if (isRecord(value)) out[key] = { optional: value["optional"] === true }
-      }
-      return out
-    }),
-    encode: Getter.passthroughSubtype()
-  })
-)
+	Schema.decodeTo(Schema.Record(Schema.String, Schema.Struct({ optional: Schema.Boolean })), {
+		decode: Getter.transform((raw: Record<string, unknown>) => {
+			const out: Record<string, { optional: boolean }> = {};
+			for (const [key, value] of Object.entries(raw)) {
+				if (isRecord(value)) out[key] = { optional: value["optional"] === true };
+			}
+			return out;
+		}),
+		encode: Getter.passthroughSubtype(),
+	}),
+);
 
 /*
  * The `Optional…` variants below decode an empty result to `undefined`.
@@ -93,31 +95,36 @@ export const OptionalFlagRecordSchema = Schema.Record(Schema.String, Schema.Unkn
  */
 
 const absentWhenEmpty = <T extends Record<string, unknown>>(value: T): T | undefined =>
-  Object.keys(value).length > 0 ? value : undefined
+	Object.keys(value).length > 0 ? value : undefined;
 
 export const OptionalStringRecordSchema = StringRecordSchema.pipe(
-  Schema.decodeTo(Schema.UndefinedOr(Schema.Record(Schema.String, Schema.String)), {
-    decode: Getter.transform(absentWhenEmpty<Record<string, string>>),
-    encode: Getter.transform((value: Record<string, string> | undefined) => value ?? {})
-  })
-)
+	Schema.decodeTo(Schema.UndefinedOr(Schema.Record(Schema.String, Schema.String)), {
+		decode: Getter.transform(absentWhenEmpty<Record<string, string>>),
+		encode: Getter.transform((value: Record<string, string> | undefined) => value ?? {}),
+	}),
+);
 
 export const OptionalStringArraySchema = StringArraySchema.pipe(
-  Schema.decodeTo(Schema.UndefinedOr(Schema.Array(Schema.String)), {
-    decode: Getter.transform((value: ReadonlyArray<string>) =>
-      value.length > 0 ? value : undefined),
-    encode: Getter.transform((value: ReadonlyArray<string> | undefined) => value ?? [])
-  })
-)
+	Schema.decodeTo(Schema.UndefinedOr(Schema.Array(Schema.String)), {
+		decode: Getter.transform((value: ReadonlyArray<string>) =>
+			value.length > 0 ? value : undefined,
+		),
+		encode: Getter.transform((value: ReadonlyArray<string> | undefined) => value ?? []),
+	}),
+);
 
 export const OptionalFlagRecordOrAbsentSchema = OptionalFlagRecordSchema.pipe(
-  Schema.decodeTo(
-    Schema.UndefinedOr(Schema.Record(Schema.String, Schema.Struct({ optional: Schema.Boolean }))),
-    {
-      decode: Getter.transform(absentWhenEmpty<Record<string, { readonly optional: boolean }>>),
-      encode: Getter.transform(
-        (value: Record<string, { readonly optional: boolean }> | undefined) => value ?? {}
-      )
-    }
-  )
-)
+	Schema.decodeTo(
+		Schema.UndefinedOr(
+			Schema.Record(Schema.String, Schema.Struct({ optional: Schema.Boolean })),
+		),
+		{
+			decode: Getter.transform(
+				absentWhenEmpty<Record<string, { readonly optional: boolean }>>,
+			),
+			encode: Getter.transform(
+				(value: Record<string, { readonly optional: boolean }> | undefined) => value ?? {},
+			),
+		},
+	),
+);

package/src/schemas/package-json.ts

@@ -11,17 +11,18 @@
  * is what `tolerant` buys: a `dependencies: "all of them"` loses one block, not
  * the file.
  */
-import * as Schema from "effect/Schema"
-import { OptionalFlagRecordSchema, StringRecordSchema, tolerant } from "./lenient.js"
+import * as Schema from "effect/Schema";
+
+import { OptionalFlagRecordSchema, StringRecordSchema, tolerant } from "./lenient.js";
 
 export const PackageJsonSchema = Schema.Struct({
-  dependencies: tolerant(StringRecordSchema),
-  devDependencies: tolerant(StringRecordSchema),
-  optionalDependencies: tolerant(StringRecordSchema),
-  peerDependencies: tolerant(StringRecordSchema),
-  peerDependenciesMeta: tolerant(OptionalFlagRecordSchema)
-})
+	dependencies: tolerant(StringRecordSchema),
+	devDependencies: tolerant(StringRecordSchema),
+	optionalDependencies: tolerant(StringRecordSchema),
+	peerDependencies: tolerant(StringRecordSchema),
+	peerDependenciesMeta: tolerant(OptionalFlagRecordSchema),
+});
 
-export type PackageJson = typeof PackageJsonSchema.Type
+export type PackageJson = typeof PackageJsonSchema.Type;
 
-export const decodePackageJson = Schema.decodeUnknownOption(PackageJsonSchema)
+export const decodePackageJson = Schema.decodeUnknownOption(PackageJsonSchema);

package/src/spec.ts

@@ -5,82 +5,83 @@
  * Deliberately dependency-light and synchronous: parsing must never touch the
  * network, so `--dry-run` and argument validation stay instant.
  */
-import semver from "semver"
-import { InvalidSpecError } from "./errors.js"
+import semver from "semver";
+
+import { InvalidSpecError } from "./errors.js";
 
 /** How a spec narrows down which version(s) of a package we want. */
 export type Selector =
-  /** An exact, fully-qualified version: `react@18.2.0`. */
-  | { readonly _tag: "Exact"; readonly version: string }
-  /** A semver range: `react@^18`, `react@>=17 <19`, `react@*`. */
-  | { readonly _tag: "Range"; readonly range: string }
-  /** A dist-tag: `react@latest`, `typescript@next`. */
-  | { readonly _tag: "Tag"; readonly tag: string }
+	/** An exact, fully-qualified version: `react@18.2.0`. */
+	| { readonly _tag: "Exact"; readonly version: string }
+	/** A semver range: `react@^18`, `react@>=17 <19`, `react@*`. */
+	| { readonly _tag: "Range"; readonly range: string }
+	/** A dist-tag: `react@latest`, `typescript@next`. */
+	| { readonly _tag: "Tag"; readonly tag: string };
 
 /** A parsed, validated package spec. */
 export type PackageSpec = {
-  /** The npm package name, including scope. */
-  readonly name: string
-  /** What the user asked for after the `@`. */
-  readonly selector: Selector
-  /** The original string, kept verbatim for error messages and the manifest. */
-  readonly raw: string
-}
+	/** The npm package name, including scope. */
+	readonly name: string;
+	/** What the user asked for after the `@`. */
+	readonly selector: Selector;
+	/** The original string, kept verbatim for error messages and the manifest. */
+	readonly raw: string;
+};
 
-const MAX_NAME_LENGTH = 214
+const MAX_NAME_LENGTH = 214;
 
 // The registry accepts URL-safe characters plus `-`, `.` and `_`.
-const SEGMENT_RE = /^[a-z0-9\-._~]+$/
+const SEGMENT_RE = /^[a-z0-9\-._~]+$/;
 
-const DIST_TAG_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/
+const DIST_TAG_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 
 /** Renders a spec back into the canonical `name@selector` form. */
 export const formatSpec = (spec: PackageSpec): string =>
-  `${spec.name}@${formatSelector(spec.selector)}`
+	`${spec.name}@${formatSelector(spec.selector)}`;
 
 /** Human-readable form of just the selector part. */
 export const formatSelector = (selector: Selector): string => {
-  switch (selector._tag) {
-    case "Exact":
-      return selector.version
-    case "Range":
-      return selector.range
-    case "Tag":
-      return selector.tag
-  }
-}
+	switch (selector._tag) {
+		case "Exact":
+			return selector.version;
+		case "Range":
+			return selector.range;
+		case "Tag":
+			return selector.tag;
+	}
+};
 
 /**
  * Validates an npm package name against the rules the registry actually
  * enforces. Returns `null` when valid, or the reason it is not.
  */
 export const validatePackageName = (name: string): string | null => {
-  if (name.length === 0) return "name is empty"
-  if (name.length > MAX_NAME_LENGTH) {
-    return `name is longer than ${MAX_NAME_LENGTH} characters`
-  }
-  if (name.trim() !== name) return "name has leading or trailing whitespace"
-  if (name.startsWith(".")) return "name cannot start with a period"
-  if (name.startsWith("_")) return "name cannot start with an underscore"
-  if (name !== name.toLowerCase()) return "name cannot contain capital letters"
-
-  if (name.startsWith("@")) {
-    const slash = name.indexOf("/")
-    if (slash === -1) return "scoped name is missing the '/name' part"
-    const scope = name.slice(1, slash)
-    const rest = name.slice(slash + 1)
-    if (scope.length === 0) return "scope is empty"
-    if (rest.length === 0) return "name after the scope is empty"
-    if (rest.includes("/")) return "name contains more than one '/'"
-    if (!SEGMENT_RE.test(scope)) return `scope "${scope}" contains illegal characters`
-    if (!SEGMENT_RE.test(rest)) return `name "${rest}" contains illegal characters`
-    return null
-  }
-
-  if (name.includes("/")) return "unscoped name cannot contain '/'"
-  if (!SEGMENT_RE.test(name)) return "name contains illegal characters"
-  return null
-}
+	if (name.length === 0) return "name is empty";
+	if (name.length > MAX_NAME_LENGTH) {
+		return `name is longer than ${MAX_NAME_LENGTH} characters`;
+	}
+	if (name.trim() !== name) return "name has leading or trailing whitespace";
+	if (name.startsWith(".")) return "name cannot start with a period";
+	if (name.startsWith("_")) return "name cannot start with an underscore";
+	if (name !== name.toLowerCase()) return "name cannot contain capital letters";
+
+	if (name.startsWith("@")) {
+		const slash = name.indexOf("/");
+		if (slash === -1) return "scoped name is missing the '/name' part";
+		const scope = name.slice(1, slash);
+		const rest = name.slice(slash + 1);
+		if (scope.length === 0) return "scope is empty";
+		if (rest.length === 0) return "name after the scope is empty";
+		if (rest.includes("/")) return "name contains more than one '/'";
+		if (!SEGMENT_RE.test(scope)) return `scope "${scope}" contains illegal characters`;
+		if (!SEGMENT_RE.test(rest)) return `name "${rest}" contains illegal characters`;
+		return null;
+	}
+
+	if (name.includes("/")) return "unscoped name cannot contain '/'";
+	if (!SEGMENT_RE.test(name)) return "name contains illegal characters";
+	return null;
+};
 
 /**
  * Parses a single spec string.
@@ -89,51 +90,51 @@ export const validatePackageName = (name: string): string | null => {
  * look for the last `@` that is not at index 0.
  */
 export const parseSpec = (raw: string): PackageSpec => {
-  const input = raw.trim()
-  if (input.length === 0) {
-    throw new InvalidSpecError(raw, "spec is empty")
-  }
+	const input = raw.trim();
+	if (input.length === 0) {
+		throw new InvalidSpecError(raw, "spec is empty");
+	}
 
-  const at = input.lastIndexOf("@")
-  const hasSelector = at > 0
-  const name = hasSelector ? input.slice(0, at) : input
-  const selectorText = hasSelector ? input.slice(at + 1) : ""
+	const at = input.lastIndexOf("@");
+	const hasSelector = at > 0;
+	const name = hasSelector ? input.slice(0, at) : input;
+	const selectorText = hasSelector ? input.slice(at + 1) : "";
 
-  const nameProblem = validatePackageName(name)
-  if (nameProblem !== null) {
-    throw new InvalidSpecError(raw, nameProblem)
-  }
+	const nameProblem = validatePackageName(name);
+	if (nameProblem !== null) {
+		throw new InvalidSpecError(raw, nameProblem);
+	}
 
-  if (!hasSelector || selectorText.length === 0) {
-    return { name, selector: { _tag: "Tag", tag: "latest" }, raw: input }
-  }
+	if (!hasSelector || selectorText.length === 0) {
+		return { name, selector: { _tag: "Tag", tag: "latest" }, raw: input };
+	}
 
-  return { name, selector: parseSelector(raw, selectorText), raw: input }
-}
+	return { name, selector: parseSelector(raw, selectorText), raw: input };
+};
 
 /** Classifies the part after the `@` as an exact version, a range, or a dist-tag. */
 export const parseSelector = (raw: string, text: string): Selector => {
-  // `semver.valid` only accepts a complete `x.y.z`, which is exactly the
-  // "pin me to this one version" case.
-  const exact = semver.valid(text, { loose: false })
-  if (exact !== null) {
-    return { _tag: "Exact", version: exact }
-  }
-
-  if (semver.validRange(text, { loose: false }) !== null) {
-    return { _tag: "Range", range: text }
-  }
-
-  // Anything left has to be a dist-tag. Tags may not look like versions and
-  // may not contain characters that would break a registry URL.
-  if (!DIST_TAG_RE.test(text)) {
-    throw new InvalidSpecError(
-      raw,
-      `"${text}" is not a valid version, semver range, or dist-tag`
-    )
-  }
-  return { _tag: "Tag", tag: text }
-}
+	// `semver.valid` only accepts a complete `x.y.z`, which is exactly the
+	// "pin me to this one version" case.
+	const exact = semver.valid(text, { loose: false });
+	if (exact !== null) {
+		return { _tag: "Exact", version: exact };
+	}
+
+	if (semver.validRange(text, { loose: false }) !== null) {
+		return { _tag: "Range", range: text };
+	}
+
+	// Anything left has to be a dist-tag. Tags may not look like versions and
+	// may not contain characters that would break a registry URL.
+	if (!DIST_TAG_RE.test(text)) {
+		throw new InvalidSpecError(
+			raw,
+			`"${text}" is not a valid version, semver range, or dist-tag`,
+		);
+	}
+	return { _tag: "Tag", tag: text };
+};
 
 /**
  * Parses many specs, collecting *every* failure rather than stopping at the
@@ -141,23 +142,26 @@ export const parseSelector = (raw: string, text: string): Selector => {
  * in one go, not made to re-run four times.
  */
 export const parseSpecs = (
-  inputs: ReadonlyArray<string>
-): { readonly specs: ReadonlyArray<PackageSpec>; readonly errors: ReadonlyArray<InvalidSpecError> } => {
-  const specs: Array<PackageSpec> = []
-  const errors: Array<InvalidSpecError> = []
-  for (const input of inputs) {
-    try {
-      specs.push(parseSpec(input))
-    } catch (error) {
-      if (error instanceof InvalidSpecError) {
-        errors.push(error)
-      } else {
-        throw error
-      }
-    }
-  }
-  return { specs, errors }
-}
+	inputs: ReadonlyArray<string>,
+): {
+	readonly specs: ReadonlyArray<PackageSpec>;
+	readonly errors: ReadonlyArray<InvalidSpecError>;
+} => {
+	const specs: Array<PackageSpec> = [];
+	const errors: Array<InvalidSpecError> = [];
+	for (const input of inputs) {
+		try {
+			specs.push(parseSpec(input));
+		} catch (error) {
+			if (error instanceof InvalidSpecError) {
+				errors.push(error);
+			} else {
+				throw error;
+			}
+		}
+	}
+	return { specs, errors };
+};
 
 /**
  * Collapses duplicate specs, keeping the first occurrence.
@@ -166,13 +170,13 @@ export const parseSpecs = (
  * download React twice.
  */
 export const dedupeSpecs = (specs: ReadonlyArray<PackageSpec>): ReadonlyArray<PackageSpec> => {
-  const seen = new Set<string>()
-  const out: Array<PackageSpec> = []
-  for (const spec of specs) {
-    const key = formatSpec(spec)
-    if (seen.has(key)) continue
-    seen.add(key)
-    out.push(spec)
-  }
-  return out
-}
+	const seen = new Set<string>();
+	const out: Array<PackageSpec> = [];
+	for (const spec of specs) {
+		const key = formatSpec(spec);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push(spec);
+	}
+	return out;
+};

package/src/types/value-of.ts

@@ -5,4 +5,4 @@
  * package: the object is the value, `ValueOf<typeof X>` is the type, and the two
  * share one name.
  */
-export type ValueOf<T> = T[keyof T]
+export type ValueOf<T> = T[keyof T];

package/src/utils/is-record.ts

@@ -5,4 +5,4 @@
  * package.json files, registry responses — without reaching for a cast.
  */
 export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
+	typeof value === "object" && value !== null && !Array.isArray(value);