@zgeoff/chex 0.2.1 → 0.2.3

package/README.md

@@ -82,8 +82,8 @@ skipped file back:
 
 `chex init` writes the `extends` line and a
 [`chex-baseline` job](../../docs/architecture/pre-push-baseline.md#a-checkout-without-the-baseline)
-into `lefthook.yml`, and adds a `check:docs` script of `chex prose length links skill` when the repo
-has none, and changes nothing on a second run. `chex ci-plan` plans a run of `bun-checks`.
+into `lefthook.yml`, and adds a `check:docs` script of `chex prose length links readmes skill` when
+the repo has none, and changes nothing on a second run. `chex ci-plan` plans a run of `bun-checks`.
 
 ## The pre-push baseline
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/chex",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Run each shared docs and repo check as one subcommand, with the lefthook pre-push baseline that calls them",
   "keywords": [
     "checks",

package/src/build-init-package.ts

@@ -2,7 +2,7 @@ import { isRecord } from '@zgeoff/std';
 
 // The baseline's jobs run chex, the related tests through rig, and each job under diet's memory cap.
 export const baselinePackages = ['@zgeoff/chex', '@zgeoff/rig', '@zgeoff/diet'] as const;
-export const docsScript = 'chex prose length links skill';
+export const docsScript = 'chex prose length links readmes skill';
 
 export type PackageOutcome =
   | { readonly kind: 'missing'; readonly packages: readonly string[] }

package/src/dependency-gates/collect-unneeded-overrides.ts

@@ -8,16 +8,31 @@ interface UnneededOverridesInput {
 }
 
 export function collectUnneededOverrides(input: UnneededOverridesInput): DependencyGateFinding[] {
-  return Object.entries(input.overrides).flatMap(([name, pin]) => {
+  return Object.entries(input.overrides).flatMap(([key, pin]) => {
+    const target = parseOverrideKey(key);
+
+    if (target === null) {
+      return [
+        {
+          path: 'package.json',
+          entry: key,
+          problem: 'bun ignores an override key with more than one parent level',
+        },
+      ];
+    }
+
     const ranges = input.dependents
-      .filter((dependent) => dependent.name === name)
-      .map((dependent) => resolveCatalogRange(input, name, dependent.range));
+      .filter(
+        (dependent) =>
+          dependent.name === target.name && isDependentOfParent(dependent, target.parent),
+      )
+      .map((dependent) => resolveCatalogRange(input, target.name, dependent.range));
 
     if (ranges.length === 0) {
       return [
         {
           path: 'package.json',
-          entry: name,
+          entry: key,
           problem: 'no package in bun.lock depends on the overridden package',
         },
       ];
@@ -27,7 +42,7 @@ export function collectUnneededOverrides(input: UnneededOverridesInput): Depende
       (range) => !isSemverRange(range) || !Bun.semver.satisfies(pin, range),
     );
 
-    const isPinTheCatalogVersion = input.catalog[name] === pin;
+    const isPinTheCatalogVersion = input.catalog[target.name] === pin;
 
     if (isPinOutsideARange || isPinTheCatalogVersion) {
       return [];
@@ -36,13 +51,74 @@ export function collectUnneededOverrides(input: UnneededOverridesInput): Depende
     return [
       {
         path: 'package.json',
-        entry: name,
+        entry: key,
         problem: `every range in bun.lock already admits ${pin}, so the override changes nothing`,
       },
     ];
   });
 }
 
+interface PackageSpec {
+  readonly name: string;
+  readonly range: string | null;
+}
+
+interface OverrideTarget {
+  readonly name: string;
+  readonly parent: PackageSpec | null;
+}
+
+// Bun splits a key at the first `>` that follows no space, `|`, `@` or `:`, so the `>` of a range
+// such as `left-pad@>=1` stays in the range.
+const parentSeparatorPattern = /[^ |@:]>/u;
+
+// A child range, as in `terser@4`, narrows the dependents bun applies the key to. The check keeps
+// every dependent of the name, so a narrower key can only look more needed, never less.
+function parseOverrideKey(key: string): OverrideTarget | null {
+  const separator = parentSeparatorPattern.exec(key);
+
+  if (separator === null) {
+    return { name: parsePackageSpec(key).name, parent: null };
+  }
+
+  const separatorIndex = separator.index + 1;
+  const child = key.slice(separatorIndex + 1).trim();
+
+  if (parentSeparatorPattern.test(child)) {
+    return null;
+  }
+
+  return {
+    name: parsePackageSpec(child).name,
+    parent: parsePackageSpec(key.slice(0, separatorIndex).trim()),
+  };
+}
+
+// A scoped name starts with `@`, so the range starts at the next `@`.
+function parsePackageSpec(spec: string): PackageSpec {
+  const rangeIndex = spec.indexOf('@', 1);
+
+  if (rangeIndex === -1) {
+    return { name: spec, range: null };
+  }
+
+  return { name: spec.slice(0, rangeIndex), range: spec.slice(rangeIndex + 1) };
+}
+
+function isDependentOfParent(dependent: LockfileDependent, parent: PackageSpec | null): boolean {
+  if (parent === null) {
+    return true;
+  }
+
+  const id = parsePackageSpec(dependent.dependent);
+
+  if (id.name !== parent.name) {
+    return false;
+  }
+
+  return parent.range === null || id.range === null || Bun.semver.satisfies(id.range, parent.range);
+}
+
 // bun.lock keeps a workspace's `catalog:` reference as it is written in its package.json.
 function resolveCatalogRange(input: UnneededOverridesInput, name: string, range: string): string {
   if (!range.startsWith('catalog:')) {

package/src/dependency-gates/parse-lockfile-dependents.ts

@@ -32,11 +32,24 @@ const workspaceFields = [
 ] as const;
 
 function collectWorkspaceDependents(path: string, workspace: unknown): LockfileDependent[] {
-  const dependent = path === '' ? 'the root workspace' : path;
+  const dependent = buildWorkspaceID(path, workspace);
 
   return collectDeclaredRanges(dependent, workspace, workspaceFields);
 }
 
+// A nested override key names its parent by package name, whether the parent is a workspace or a
+// registry package, so a workspace with a name takes it in place of its path.
+function buildWorkspaceID(path: string, workspace: unknown): string {
+  const name = isRecord(workspace) ? workspace['name'] : undefined;
+  const version = isRecord(workspace) ? workspace['version'] : undefined;
+
+  if (typeof name !== 'string') {
+    return path === '' ? 'the root workspace' : path;
+  }
+
+  return typeof version === 'string' ? `${name}@${version}` : name;
+}
+
 function collectDeclaredRanges(
   dependent: string,
   metadata: unknown,

package/src/dependency-gates/parse-root-manifest.ts

@@ -21,13 +21,55 @@ export function parseRootManifest(text: string): RootManifest {
   const audit = isRecord(scripts) ? scripts['audit'] : undefined;
 
   return {
-    overrides: parseVersions(manifest['overrides'], 'overrides'),
+    overrides: parseOverrides(manifest['overrides']),
     catalog: parseVersions(catalog, 'workspaces.catalog'),
     catalogs: parseNamedCatalogs(catalogs),
     auditScript: typeof audit === 'string' ? audit : '',
   };
 }
 
+function parseOverrides(value: unknown): Record<string, string> {
+  if (value === undefined) {
+    return {};
+  }
+
+  if (!isRecord(value)) {
+    throw new TypeError('package.json sets overrides to a value that is not an object');
+  }
+
+  return Object.fromEntries(collectOverrideEntries('', value));
+}
+
+// Bun reads `{ "a": { ".": "1.0.0", "b": "2.0.0" } }` as the keys `a` and `a>b`.
+function collectOverrideEntries(
+  parentKey: string,
+  overrides: Record<string, unknown>,
+): [string, string][] {
+  return Object.entries(overrides).flatMap(([name, value]): [string, string][] => {
+    const key = buildOverrideKey(parentKey, name);
+
+    if (typeof value === 'string') {
+      return [[key, value]];
+    }
+
+    if (isRecord(value)) {
+      return collectOverrideEntries(key, value);
+    }
+
+    throw new TypeError(
+      `package.json sets the overrides entry for ${key} to a value that is not a version`,
+    );
+  });
+}
+
+function buildOverrideKey(parentKey: string, name: string): string {
+  if (name === '.') {
+    return parentKey;
+  }
+
+  return parentKey === '' ? name : `${parentKey}>${name}`;
+}
+
 function parseVersions(value: unknown, field: string): Record<string, string> {
   if (value === undefined) {
     return {};