@riebeckite/test 0.0.21 → 0.0.23

package/dist/e2e/index.js

@@ -317,8 +317,52 @@ function createLogger(label = "e2e") {
 // e2e/pack.ts
 import fs3 from "node:fs";
 import path4 from "node:path";
+function assertPackArtifacts(packageDir, pkg) {
+  const manifest = JSON.parse(
+    fs3.readFileSync(path4.join(packageDir, "package.json"), "utf8")
+  );
+  if (manifest.files?.includes("dist") && !fs3.existsSync(path4.join(packageDir, "dist"))) {
+    throw new Error(
+      `Cannot pack ${pkg.name}: dist/ is missing. Build workspace packages before running isolated package tests.`
+    );
+  }
+}
+function packageLevels(repoRoot, packages) {
+  const byName = new Map(packages.map((pkg) => [pkg.name, pkg]));
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const manifest = JSON.parse(
+      fs3.readFileSync(
+        path4.join(repoRoot, pkg.directory, "package.json"),
+        "utf8"
+      )
+    );
+    dependencies.set(
+      pkg.name,
+      Object.keys(manifest.dependencies ?? {}).filter(
+        (name) => byName.has(name)
+      )
+    );
+  }
+  const remaining = new Set(byName.keys());
+  const levels = [];
+  while (remaining.size > 0) {
+    const level = packages.filter(
+      (pkg) => remaining.has(pkg.name) && (dependencies.get(pkg.name) ?? []).every(
+        (dependency) => !remaining.has(dependency)
+      )
+    );
+    if (level.length === 0) {
+      throw new Error("Workspace package dependency cycle");
+    }
+    levels.push(level);
+    for (const pkg of level) remaining.delete(pkg.name);
+  }
+  return levels;
+}
 async function packPackages(tarballDir, options) {
   const { repoRoot, packages, logger, concurrency = 4 } = options;
+  const levels = packageLevels(repoRoot, packages);
   logger.step(
     `packing ${packages.length} packages with pnpm pack (concurrency ${concurrency})`
   );
@@ -327,12 +371,20 @@ async function packPackages(tarballDir, options) {
     if (!fs3.existsSync(packageDir)) {
       logger.fail(`Package directory is missing: ${pkg.directory}`);
     }
+    assertPackArtifacts(packageDir, pkg);
     const manifest = JSON.parse(
       fs3.readFileSync(path4.join(packageDir, "package.json"), "utf8")
     );
-    await runAsync("pnpm", ["pack", "--pack-destination", tarballDir], {
-      cwd: packageDir
-    });
+    await runAsync(
+      "pnpm",
+      [
+        "--config.ignore-scripts=true",
+        "pack",
+        "--pack-destination",
+        tarballDir
+      ],
+      { cwd: packageDir }
+    );
     const sanitized = pkg.name.replace(/^@/, "").replace(/\//g, "-");
     const tarball = path4.join(
       tarballDir,
@@ -344,28 +396,30 @@ async function packPackages(tarballDir, options) {
     console.log(`  packed ${pkg.name} -> ${path4.basename(tarball)}`);
     return { pkg, version: manifest.version, tarball };
   };
-  const results = new Array(packages.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (nextIndex < packages.length) {
-      const index = nextIndex;
-      nextIndex += 1;
-      const pkg = packages[index];
-      if (pkg === void 0) continue;
-      results[index] = await packOne(pkg);
-    }
-  };
-  const batch = await Promise.allSettled(
-    Array.from(
-      { length: Math.min(concurrency, packages.length) },
-      () => worker()
-    )
-  );
-  const failure = batch.find(
-    (result) => result.status === "rejected"
-  );
-  if (failure) {
-    throw failure.reason;
+  const results = [];
+  for (const level of levels) {
+    const levelResults = new Array(level.length);
+    let nextIndex = 0;
+    const worker = async () => {
+      while (nextIndex < level.length) {
+        const index = nextIndex;
+        nextIndex += 1;
+        const pkg = level[index];
+        if (pkg === void 0) continue;
+        levelResults[index] = await packOne(pkg);
+      }
+    };
+    const batch = await Promise.allSettled(
+      Array.from(
+        { length: Math.min(concurrency, level.length) },
+        () => worker()
+      )
+    );
+    const failure = batch.find(
+      (result) => result.status === "rejected"
+    );
+    if (failure) throw failure.reason;
+    results.push(...levelResults);
   }
   const packed = /* @__PURE__ */ new Map();
   for (const result of results) {

package/dist/e2e/pack.d.ts

@@ -22,9 +22,4 @@ export interface PackPackagesOptions {
     concurrency?: number;
     logger: Logger;
 }
-/**
- * Pack every package with `pnpm pack` into `tarballDir`, using a
- * limited-concurrency pool. Returns a map from package name to its tarball and
- * version. The first failure rejects the returned promise.
- */
 export declare function packPackages(tarballDir: string, options: PackPackagesOptions): Promise<PackedPackages>;

package/dist/fixtures.d.ts

@@ -0,0 +1,3 @@
+export type Frontmatter = Readonly<Record<string, string | number | boolean | readonly string[]>>;
+export declare function markdown(body: string, frontmatter?: Frontmatter): string;
+export declare function withTemporaryDirectory<T>(prefixOrCallback: string | ((directory: string) => Promise<T>), callback?: (directory: string) => Promise<T>): Promise<T>;

package/dist/fixtures.js

@@ -0,0 +1,33 @@
+// fixtures.ts
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function frontmatterValue(value) {
+  if (Array.isArray(value))
+    return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+  return String(value);
+}
+function markdown(body, frontmatter) {
+  if (!frontmatter || Object.keys(frontmatter).length === 0) return body;
+  const fields = Object.entries(frontmatter).map(([key, value]) => `${key}: ${frontmatterValue(value)}`).join("\n");
+  return `---
+${fields}
+---
+
+${body}`;
+}
+async function withTemporaryDirectory(prefixOrCallback, callback) {
+  const prefix = typeof prefixOrCallback === "string" ? prefixOrCallback : "riebeckite-test-";
+  const operation = typeof prefixOrCallback === "function" ? prefixOrCallback : callback;
+  if (!operation) throw new Error("A temporary directory callback is required");
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  try {
+    return await operation(directory);
+  } finally {
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 3 });
+  }
+}
+export {
+  markdown,
+  withTemporaryDirectory
+};

package/dist/index.d.ts

@@ -8,4 +8,5 @@
  * `@riebeckite/test/e2e` entry point because it orchestrates processes, the
  * filesystem, and published tarballs.
  */
+export { type Frontmatter, markdown, withTemporaryDirectory, } from "./fixtures.js";
 export { assertGolden, assertGoldenJson, type GoldenOptions, } from "./golden.js";

package/dist/index.js

@@ -1,14 +1,44 @@
+// fixtures.ts
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+function frontmatterValue(value) {
+  if (Array.isArray(value))
+    return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+  return String(value);
+}
+function markdown(body, frontmatter) {
+  if (!frontmatter || Object.keys(frontmatter).length === 0) return body;
+  const fields = Object.entries(frontmatter).map(([key, value]) => `${key}: ${frontmatterValue(value)}`).join("\n");
+  return `---
+${fields}
+---
+
+${body}`;
+}
+async function withTemporaryDirectory(prefixOrCallback, callback) {
+  const prefix = typeof prefixOrCallback === "string" ? prefixOrCallback : "riebeckite-test-";
+  const operation = typeof prefixOrCallback === "function" ? prefixOrCallback : callback;
+  if (!operation) throw new Error("A temporary directory callback is required");
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  try {
+    return await operation(directory);
+  } finally {
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 3 });
+  }
+}
+
 // golden.ts
 import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 function normalizeText(value) {
   return `${value.replace(/\r\n?/g, "\n").replace(/\n+$/, "")}
 `;
 }
 function relative(file) {
-  return path.relative(process.cwd(), file) || file;
+  return path2.relative(process.cwd(), file) || file;
 }
 function assertGolden(actual, golden, options = {}) {
   const normalize = options.normalize ?? true;
@@ -16,15 +46,15 @@ function assertGolden(actual, golden, options = {}) {
   const file = fileURLToPath(golden);
   const label = options.message ? `${options.message}: ` : "";
   if (process.env.UPDATE_GOLDEN === "1") {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, value, "utf8");
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, value, "utf8");
     return;
   }
   assert.ok(
-    fs.existsSync(file),
+    fs2.existsSync(file),
     `${label}Missing golden file ${relative(file)}. Run \`pnpm test:update\` to create it.`
   );
-  const recorded = fs.readFileSync(file, "utf8");
+  const recorded = fs2.readFileSync(file, "utf8");
   assert.equal(
     value,
     normalize ? normalizeText(recorded) : recorded,
@@ -36,5 +66,7 @@ function assertGoldenJson(value, golden, options = {}) {
 }
 export {
   assertGolden,
-  assertGoldenJson
+  assertGoldenJson,
+  markdown,
+  withTemporaryDirectory
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/test",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,6 +17,12 @@
       "import": "./dist/e2e/index.js",
       "source": "./e2e/index.ts",
       "default": "./dist/e2e/index.js"
+    },
+    "./fixtures": {
+      "types": "./dist/fixtures.d.ts",
+      "import": "./dist/fixtures.js",
+      "source": "./fixtures.ts",
+      "default": "./dist/fixtures.js"
     }
   },
   "files": [