@funktechno/multi-assert 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MultiAssertError: () => MultiAssertError,
+  configure: () => configure,
+  multiAssert: () => multiAssert,
+  multiAssertAsync: () => multiAssertAsync
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/format.ts
+var red = (s) => `\x1B[31m${s}\x1B[39m`;
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+function shouldUseColor(color) {
+  if (color === true || color === false) return color;
+  if (typeof process === "undefined") return false;
+  const env = process.env ?? {};
+  return Boolean(process.stdout?.isTTY) && !env.NO_COLOR && !env.CI;
+}
+function summaryLine(failed, total, heading) {
+  const noun = total === 1 ? "assertion" : "assertions";
+  return `${failed} of ${total} ${noun} failed${heading ? ` (${heading})` : ""}`;
+}
+var INDENT = "       ";
+function formatFailures(failures, total, options) {
+  const paint = (fn, s) => options.color ? fn(s) : s;
+  const blocks = failures.map((failure) => {
+    const lines = failure.message.split("\n");
+    const title = failure.label ?? lines.shift() ?? "";
+    const out = [`  ${paint(red, "\u2715")} ${failure.index}) ${title}`];
+    for (const line of lines) out.push(line ? `${INDENT}${line}` : "");
+    const frames = (options.frames.get(failure) ?? []).slice(0, options.stackFrames);
+    for (const frame of frames) out.push(paint(dim, `${INDENT}\u2192 ${frame}`));
+    return out.join("\n");
+  });
+  return `${summaryLine(failures.length, total, options.heading)}
+
+${blocks.join("\n\n")}`;
+}
+
+// src/MultiAssertError.ts
+var MultiAssertError = class extends AggregateError {
+  constructor(errors, message, failures, total) {
+    super(errors, message);
+    this.name = "MultiAssertError";
+    const hidden = { enumerable: false, writable: false, configurable: true };
+    Object.defineProperties(this, {
+      failures: { value: failures, ...hidden },
+      total: { value: total, ...hidden },
+      passed: { value: total - failures.length, ...hidden }
+    });
+  }
+  /**
+   * Keeps `name` and `message` so reporters that serialise errors with `toJSON` (Vitest) still
+   * show the summary, and adds the structured failures.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      passed: this.passed,
+      total: this.total,
+      failures: this.failures
+    };
+  }
+};
+
+// src/normalize.ts
+var ESC = String.fromCharCode(27);
+var ANSI = new RegExp(`(?:${ESC}|\\\\u001b|\\\\x1b)\\[[0-9;?]*[A-Za-z]`, "g");
+var stripAnsi = (text) => text.replace(ANSI, "");
+var isObject = (value) => typeof value === "object" && value !== null;
+function safeInspect(value, max = 500) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let text;
+  try {
+    text = JSON.stringify(
+      value,
+      (_key, v) => {
+        if (typeof v === "bigint") return `${v}n`;
+        if (typeof v === "function") return `[Function ${v.name || "anonymous"}]`;
+        if (typeof v === "symbol") return v.toString();
+        if (isObject(v)) {
+          if (seen.has(v)) return "[Circular]";
+          seen.add(v);
+        }
+        return v;
+      },
+      2
+    ) ?? String(value);
+  } catch {
+    text = String(value);
+  }
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+var matcherAdapter = {
+  name: "matcher",
+  matches: (e) => isObject(e) && isObject(e.matcherResult),
+  normalize(e) {
+    const result = e.matcherResult;
+    let message = result.message;
+    if (typeof message === "function") message = message();
+    if (Array.isArray(message)) message = message.join("\n");
+    return {
+      message: typeof message === "string" ? message : String(e.message ?? ""),
+      actual: result.actual,
+      expected: result.expected,
+      operator: typeof result.name === "string" ? result.name : void 0
+    };
+  }
+};
+var assertionAdapter = {
+  name: "assertion",
+  matches: (e) => e instanceof Error && ("actual" in e || "expected" in e || "operator" in e || e.name === "AssertionError"),
+  normalize(e) {
+    const err = e;
+    return {
+      message: err.message,
+      actual: err.actual,
+      expected: err.expected,
+      operator: typeof err.operator === "string" ? err.operator : void 0
+    };
+  }
+};
+var errorAdapter = {
+  name: "error",
+  matches: (e) => e instanceof Error || isObject(e) && typeof e.message === "string",
+  normalize(e) {
+    const err = e;
+    const message = err.message ? `${err.name}: ${err.message}` : String(err.name ?? "Error");
+    return { message };
+  }
+};
+var otherAdapter = {
+  name: "other",
+  matches: () => true,
+  normalize: (e) => ({ message: `[non-Error thrown] ${safeInspect(e)}` })
+};
+var builtInAdapters = [
+  matcherAdapter,
+  assertionAdapter,
+  errorAdapter,
+  otherAdapter
+];
+function normalizeError(error, custom = []) {
+  const adapter = [...custom, ...builtInAdapters].find((a) => {
+    try {
+      return a.matches(error);
+    } catch {
+      return false;
+    }
+  });
+  const normalized = adapter.normalize(error);
+  return { ...normalized, message: stripAnsi(normalized.message) };
+}
+var OWN_FRAME = /[\\/]multi-assert[\\/](?:src|dist)[\\/]/;
+var FRAME_LOCATION = /\(?((?:file:\/\/)?[^\s()]+?:\d+:\d+)\)?\s*$/;
+function userFrames(stack) {
+  if (!stack) return [];
+  return stack.split("\n").filter((line) => /^\s*at /.test(line)).filter(
+    (line) => !line.includes("node_modules") && !line.includes("node:") && !OWN_FRAME.test(line)
+  ).map((line) => FRAME_LOCATION.exec(line)?.[1]).filter((loc) => Boolean(loc)).map(relativize);
+}
+function relativize(location) {
+  const withoutScheme = location.replace(/^file:\/\//, "").replace(/^\/([A-Za-z]:)/, "$1");
+  const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : void 0;
+  if (!cwd) return withoutScheme;
+  const norm = (p) => p.replace(/\\/g, "/");
+  const base = norm(cwd).replace(/\/$/, "") + "/";
+  const loc = norm(withoutScheme);
+  return loc.toLowerCase().startsWith(base.toLowerCase()) ? loc.slice(base.length) : loc;
+}
+
+// src/multiAssert.ts
+var defaults = {
+  rethrowSingle: true,
+  color: "auto",
+  stackFrames: 1,
+  adapters: []
+};
+function configure(options) {
+  Object.assign(defaults, options);
+}
+function toEntries(checks) {
+  const pairs = Array.isArray(checks) ? checks.map((c) => Array.isArray(c) ? [c[0], c[1]] : [void 0, c]) : Object.entries(checks ?? {});
+  return pairs.map(([label, fn], i) => {
+    if (typeof fn !== "function") {
+      throw new TypeError(
+        `multiAssert: check ${i + 1}${label ? ` ("${label}")` : ""} is not a function`
+      );
+    }
+    return { label, fn };
+  });
+}
+var isThenable = (value) => typeof value?.then === "function";
+function captureSite(from) {
+  const holder = {};
+  const capture = Error.captureStackTrace;
+  if (capture) {
+    capture(holder, from);
+    return holder.stack;
+  }
+  return new Error().stack;
+}
+function finish(caught, total, options, site) {
+  if (caught.length === 0) return;
+  const settings = { ...defaults, ...options };
+  const [only] = caught;
+  if (caught.length === 1 && settings.rethrowSingle && only.error instanceof Error && !only.entry.label && !settings.message) {
+    throw only.error;
+  }
+  const frames = /* @__PURE__ */ new Map();
+  const failures = caught.map(({ entry, index, error: error2 }) => {
+    const normalized = normalizeError(error2, settings.adapters);
+    const failure = {
+      index,
+      label: entry.label,
+      message: normalized.message,
+      actual: normalized.actual,
+      expected: normalized.expected,
+      operator: normalized.operator
+    };
+    const list = userFrames(error2 instanceof Error ? error2.stack : void 0);
+    failure.location = list[0];
+    frames.set(failure, list);
+    return failure;
+  });
+  const message = formatFailures(failures, total, {
+    heading: settings.message,
+    color: shouldUseColor(settings.color),
+    stackFrames: settings.stackFrames,
+    frames
+  });
+  const error = new MultiAssertError(
+    caught.map((c) => c.error),
+    message,
+    failures,
+    total
+  );
+  const callSite = (site ?? "").split("\n").filter((l) => /^\s*at /.test(l));
+  error.stack = [`${error.name}: ${message}`, ...callSite].join("\n");
+  throw error;
+}
+function multiAssert(checks, options = {}) {
+  const entries = toEntries(checks);
+  const caught = [];
+  entries.forEach((entry, i) => {
+    try {
+      const result = entry.fn();
+      if (isThenable(result)) {
+        result.then(void 0, () => void 0);
+        throw new TypeError("check returned a Promise; use multiAssertAsync() for async checks");
+      }
+    } catch (error) {
+      caught.push({ entry, index: i + 1, error });
+    }
+  });
+  finish(caught, entries.length, options, caught.length ? captureSite(multiAssert) : void 0);
+}
+async function multiAssertAsync(checks, options = {}) {
+  const site = captureSite(multiAssertAsync);
+  const entries = toEntries(checks);
+  const caught = [];
+  for (const [i, entry] of entries.entries()) {
+    try {
+      await entry.fn();
+    } catch (error) {
+      caught.push({ entry, index: i + 1, error });
+    }
+  }
+  finish(caught, entries.length, options, site);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiAssertError,
+  configure,
+  multiAssert,
+  multiAssertAsync
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/format.ts","../src/MultiAssertError.ts","../src/normalize.ts","../src/multiAssert.ts"],"sourcesContent":["export { multiAssert, multiAssertAsync, configure } from \"./multiAssert\";\nexport { MultiAssertError } from \"./MultiAssertError\";\nexport type {\n  AsyncCheck,\n  AsyncCheckFn,\n  Check,\n  CheckFn,\n  ErrorAdapter,\n  Failure,\n  MultiAssertOptions,\n  NormalizedError,\n} from \"./types\";\n","import type { Failure, MultiAssertOptions } from \"./types\";\n\nconst red = (s: string) => `\\u001b[31m${s}\\u001b[39m`;\nconst dim = (s: string) => `\\u001b[2m${s}\\u001b[22m`;\n\nexport function shouldUseColor(color: MultiAssertOptions[\"color\"]): boolean {\n  if (color === true || color === false) return color;\n  if (typeof process === \"undefined\") return false;\n  const env = process.env ?? {};\n  return Boolean(process.stdout?.isTTY) && !env.NO_COLOR && !env.CI;\n}\n\nexport function summaryLine(failed: number, total: number, heading?: string): string {\n  const noun = total === 1 ? \"assertion\" : \"assertions\";\n  return `${failed} of ${total} ${noun} failed${heading ? ` (${heading})` : \"\"}`;\n}\n\nconst INDENT = \"       \";\n\nexport interface FormatOptions {\n  heading?: string;\n  color: boolean;\n  stackFrames: number;\n  frames: Map<Failure, string[]>;\n}\n\nexport function formatFailures(failures: Failure[], total: number, options: FormatOptions): string {\n  const paint = (fn: (s: string) => string, s: string) => (options.color ? fn(s) : s);\n  const blocks = failures.map((failure) => {\n    const lines = failure.message.split(\"\\n\");\n    const title = failure.label ?? lines.shift() ?? \"\";\n    const out = [`  ${paint(red, \"✕\")} ${failure.index}) ${title}`];\n    for (const line of lines) out.push(line ? `${INDENT}${line}` : \"\");\n    const frames = (options.frames.get(failure) ?? []).slice(0, options.stackFrames);\n    for (const frame of frames) out.push(paint(dim, `${INDENT}→ ${frame}`));\n    return out.join(\"\\n\");\n  });\n  return `${summaryLine(failures.length, total, options.heading)}\\n\\n${blocks.join(\"\\n\\n\")}`;\n}\n","import type { Failure } from \"./types\";\n\n/** Thrown when two or more checks in a group fail (or one fails and can't be rethrown as is). */\nexport class MultiAssertError extends AggregateError {\n  declare readonly failures: Failure[];\n  declare readonly passed: number;\n  declare readonly total: number;\n\n  constructor(errors: unknown[], message: string, failures: Failure[], total: number) {\n    super(errors, message);\n    this.name = \"MultiAssertError\";\n    // Non-enumerable so reporters that dump an error's own properties (Vitest does) don't print\n    // the same failures twice.\n    const hidden = { enumerable: false, writable: false, configurable: true };\n    Object.defineProperties(this, {\n      failures: { value: failures, ...hidden },\n      total: { value: total, ...hidden },\n      passed: { value: total - failures.length, ...hidden },\n    });\n  }\n\n  /**\n   * Keeps `name` and `message` so reporters that serialise errors with `toJSON` (Vitest) still\n   * show the summary, and adds the structured failures.\n   */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      passed: this.passed,\n      total: this.total,\n      failures: this.failures,\n    };\n  }\n}\n","import type { ErrorAdapter, NormalizedError } from \"./types\";\n\nconst ESC = String.fromCharCode(27);\n/** Every ANSI CSI sequence, plus the already-escaped text form some reporters print. */\nconst ANSI = new RegExp(`(?:${ESC}|\\\\\\\\u001b|\\\\\\\\x1b)\\\\[[0-9;?]*[A-Za-z]`, \"g\");\n\nexport const stripAnsi = (text: string): string => text.replace(ANSI, \"\");\n\nconst isObject = (value: unknown): value is Record<string, any> =>\n  typeof value === \"object\" && value !== null;\n\n/** Cycle-safe, truncated rendering for values that aren't Errors. */\nexport function safeInspect(value: unknown, max = 500): string {\n  const seen = new WeakSet<object>();\n  let text: string;\n  try {\n    text =\n      JSON.stringify(\n        value,\n        (_key, v) => {\n          if (typeof v === \"bigint\") return `${v}n`;\n          if (typeof v === \"function\") return `[Function ${v.name || \"anonymous\"}]`;\n          if (typeof v === \"symbol\") return v.toString();\n          if (isObject(v)) {\n            if (seen.has(v)) return \"[Circular]\";\n            seen.add(v);\n          }\n          return v;\n        },\n        2,\n      ) ?? String(value);\n  } catch {\n    text = String(value);\n  }\n  return text.length > max ? `${text.slice(0, max)}…` : text;\n}\n\n/** Jest / Vitest / Playwright `expect` errors carry a `matcherResult`. */\nconst matcherAdapter: ErrorAdapter = {\n  name: \"matcher\",\n  matches: (e) => isObject(e) && isObject(e.matcherResult),\n  normalize(e) {\n    const result = (e as any).matcherResult;\n    let message: unknown = result.message;\n    if (typeof message === \"function\") message = message();\n    if (Array.isArray(message)) message = message.join(\"\\n\");\n    return {\n      message: typeof message === \"string\" ? message : String((e as Error).message ?? \"\"),\n      actual: result.actual,\n      expected: result.expected,\n      operator: typeof result.name === \"string\" ? result.name : undefined,\n    };\n  },\n};\n\n/** node:assert, chai, uvu and Vitest's chai-based errors expose actual / expected. */\nconst assertionAdapter: ErrorAdapter = {\n  name: \"assertion\",\n  matches: (e) =>\n    e instanceof Error &&\n    (\"actual\" in e || \"expected\" in e || \"operator\" in e || e.name === \"AssertionError\"),\n  normalize(e) {\n    const err = e as Error & { actual?: unknown; expected?: unknown; operator?: string };\n    return {\n      message: err.message,\n      actual: err.actual,\n      expected: err.expected,\n      operator: typeof err.operator === \"string\" ? err.operator : undefined,\n    };\n  },\n};\n\nconst errorAdapter: ErrorAdapter = {\n  name: \"error\",\n  matches: (e) => e instanceof Error || (isObject(e) && typeof e.message === \"string\"),\n  normalize(e) {\n    const err = e as Error;\n    const message = err.message ? `${err.name}: ${err.message}` : String(err.name ?? \"Error\");\n    return { message };\n  },\n};\n\nconst otherAdapter: ErrorAdapter = {\n  name: \"other\",\n  matches: () => true,\n  normalize: (e) => ({ message: `[non-Error thrown] ${safeInspect(e)}` }),\n};\n\nexport const builtInAdapters: ErrorAdapter[] = [\n  matcherAdapter,\n  assertionAdapter,\n  errorAdapter,\n  otherAdapter,\n];\n\nexport function normalizeError(error: unknown, custom: ErrorAdapter[] = []): NormalizedError {\n  const adapter = [...custom, ...builtInAdapters].find((a) => {\n    try {\n      return a.matches(error);\n    } catch {\n      return false;\n    }\n  }) as ErrorAdapter;\n  const normalized = adapter.normalize(error);\n  return { ...normalized, message: stripAnsi(normalized.message) };\n}\n\n/** Frames from this package's own source/dist, which should never be shown as a location. */\nconst OWN_FRAME = /[\\\\/]multi-assert[\\\\/](?:src|dist)[\\\\/]/;\nconst FRAME_LOCATION = /\\(?((?:file:\\/\\/)?[^\\s()]+?:\\d+:\\d+)\\)?\\s*$/;\n\nexport function userFrames(stack: string | undefined): string[] {\n  if (!stack) return [];\n  return stack\n    .split(\"\\n\")\n    .filter((line) => /^\\s*at /.test(line))\n    .filter(\n      (line) => !line.includes(\"node_modules\") && !line.includes(\"node:\") && !OWN_FRAME.test(line),\n    )\n    .map((line) => FRAME_LOCATION.exec(line)?.[1])\n    .filter((loc): loc is string => Boolean(loc))\n    .map(relativize);\n}\n\nfunction relativize(location: string): string {\n  // file:///C:/x -> C:/x, but file:///home/x -> /home/x\n  const withoutScheme = location.replace(/^file:\\/\\//, \"\").replace(/^\\/([A-Za-z]:)/, \"$1\");\n  const cwd = typeof process !== \"undefined\" && process.cwd ? process.cwd() : undefined;\n  if (!cwd) return withoutScheme;\n  const norm = (p: string) => p.replace(/\\\\/g, \"/\");\n  const base = norm(cwd).replace(/\\/$/, \"\") + \"/\";\n  const loc = norm(withoutScheme);\n  return loc.toLowerCase().startsWith(base.toLowerCase()) ? loc.slice(base.length) : loc;\n}\n","import { formatFailures, shouldUseColor } from \"./format\";\nimport { MultiAssertError } from \"./MultiAssertError\";\nimport { normalizeError, userFrames } from \"./normalize\";\nimport type {\n  AsyncCheck,\n  AsyncCheckFn,\n  Check,\n  CheckFn,\n  Failure,\n  MultiAssertOptions,\n} from \"./types\";\n\nconst defaults: Required<Omit<MultiAssertOptions, \"message\">> & { message?: string } = {\n  rethrowSingle: true,\n  color: \"auto\",\n  stackFrames: 1,\n  adapters: [],\n};\n\n/** Set defaults once, e.g. in a test setup file. */\nexport function configure(options: MultiAssertOptions): void {\n  Object.assign(defaults, options);\n}\n\ninterface Entry<F> {\n  label?: string;\n  fn: F;\n}\n\nfunction toEntries<F extends () => unknown>(\n  checks: Array<F | [string, F]> | Record<string, F>,\n): Entry<F>[] {\n  const pairs: Array<[string | undefined, unknown]> = Array.isArray(checks)\n    ? checks.map((c) => (Array.isArray(c) ? [c[0], c[1]] : [undefined, c]))\n    : Object.entries(checks ?? {});\n  return pairs.map(([label, fn], i) => {\n    if (typeof fn !== \"function\") {\n      throw new TypeError(\n        `multiAssert: check ${i + 1}${label ? ` (\"${label}\")` : \"\"} is not a function`,\n      );\n    }\n    return { label, fn: fn as F };\n  });\n}\n\nconst isThenable = (value: unknown): value is PromiseLike<unknown> =>\n  typeof (value as PromiseLike<unknown> | undefined)?.then === \"function\";\n\ninterface Caught {\n  entry: Entry<unknown>;\n  index: number;\n  error: unknown;\n}\n\nfunction captureSite(from: (...args: any[]) => unknown): string | undefined {\n  const holder: { stack?: string } = {};\n  const capture = (Error as any).captureStackTrace as\n    | ((target: object, ctor?: (...args: any[]) => unknown) => void)\n    | undefined;\n  if (capture) {\n    capture(holder, from);\n    return holder.stack;\n  }\n  return new Error().stack;\n}\n\nfunction finish(\n  caught: Caught[],\n  total: number,\n  options: MultiAssertOptions,\n  site: string | undefined,\n): void {\n  if (caught.length === 0) return;\n  const settings = { ...defaults, ...options };\n  const [only] = caught;\n  if (\n    caught.length === 1 &&\n    settings.rethrowSingle &&\n    only.error instanceof Error &&\n    !only.entry.label &&\n    !settings.message\n  ) {\n    throw only.error;\n  }\n\n  const frames = new Map<Failure, string[]>();\n  const failures = caught.map(({ entry, index, error }) => {\n    const normalized = normalizeError(error, settings.adapters);\n    const failure: Failure = {\n      index,\n      label: entry.label,\n      message: normalized.message,\n      actual: normalized.actual,\n      expected: normalized.expected,\n      operator: normalized.operator,\n    };\n    const list = userFrames(error instanceof Error ? error.stack : undefined);\n    failure.location = list[0];\n    frames.set(failure, list);\n    return failure;\n  });\n\n  const message = formatFailures(failures, total, {\n    heading: settings.message,\n    color: shouldUseColor(settings.color),\n    stackFrames: settings.stackFrames,\n    frames,\n  });\n  const error = new MultiAssertError(\n    caught.map((c) => c.error),\n    message,\n    failures,\n    total,\n  );\n  // Point reporters at the test that called multiAssert, not at this package.\n  const callSite = (site ?? \"\").split(\"\\n\").filter((l) => /^\\s*at /.test(l));\n  // Standard `Name: message` header, so reporters that print the stack (Jest) show every failure.\n  error.stack = [`${error.name}: ${message}`, ...callSite].join(\"\\n\");\n  throw error;\n}\n\n/**\n * Runs every check instead of stopping at the first failure, then throws once with all failures\n * combined. Checks must be synchronous; use {@link multiAssertAsync} for async checks.\n */\nexport function multiAssert(\n  checks: Check[] | Record<string, CheckFn>,\n  options: MultiAssertOptions = {},\n): void {\n  const entries = toEntries<CheckFn>(checks);\n  const caught: Caught[] = [];\n  entries.forEach((entry, i) => {\n    try {\n      const result = entry.fn();\n      if (isThenable(result)) {\n        // Avoid an unhandled rejection from a promise we are not going to await.\n        result.then(undefined, () => undefined);\n        throw new TypeError(\"check returned a Promise; use multiAssertAsync() for async checks\");\n      }\n    } catch (error) {\n      caught.push({ entry, index: i + 1, error });\n    }\n  });\n  finish(caught, entries.length, options, caught.length ? captureSite(multiAssert) : undefined);\n}\n\n/** Like {@link multiAssert}, but awaits each check in order. */\nexport async function multiAssertAsync(\n  checks: AsyncCheck[] | Record<string, AsyncCheckFn>,\n  options: MultiAssertOptions = {},\n): Promise<void> {\n  const site = captureSite(multiAssertAsync);\n  const entries = toEntries<AsyncCheckFn>(checks);\n  const caught: Caught[] = [];\n  for (const [i, entry] of entries.entries()) {\n    try {\n      await entry.fn();\n    } catch (error) {\n      caught.push({ entry, index: i + 1, error });\n    }\n  }\n  finish(caught, entries.length, options, site);\n}\n"],"mappings":"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","names":["error"]}

package/dist/index.mjs

@@ -0,0 +1,13 @@
+import {
+  MultiAssertError,
+  configure,
+  multiAssert,
+  multiAssertAsync
+} from "./chunk-UP6HQ3WU.mjs";
+export {
+  MultiAssertError,
+  configure,
+  multiAssert,
+  multiAssertAsync
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/jest.d.mts

@@ -0,0 +1,24 @@
+import { MultiAssertOptions } from './index.mjs';
+
+type Matcher<T> = ((received: T) => unknown) | [label: string, fn: (received: T) => unknown];
+/** `expect(value).toPassAll([...])`: every check gets `value`, all failures are reported at once. */
+declare const multiAssertMatchers: {
+    toPassAll<T>(received: T, checks: Matcher<T>[], options?: MultiAssertOptions): {
+        pass: boolean;
+        message: () => string;
+    };
+};
+interface ExpectLike {
+    extend(matchers: Record<string, unknown>): void;
+}
+/** Registers `toPassAll` on a Jest-compatible `expect` (Jest, Vitest, Playwright). */
+declare function installMultiAssertMatchers(expectLike: ExpectLike): void;
+declare global {
+    namespace jest {
+        interface Matchers<R, T = unknown> {
+            toPassAll(checks: Array<((received: T) => unknown) | [label: string, fn: (received: T) => unknown]>, options?: MultiAssertOptions): R;
+        }
+    }
+}
+
+export { installMultiAssertMatchers, multiAssertMatchers };

package/dist/jest.d.ts

@@ -0,0 +1,24 @@
+import { MultiAssertOptions } from './index.js';
+
+type Matcher<T> = ((received: T) => unknown) | [label: string, fn: (received: T) => unknown];
+/** `expect(value).toPassAll([...])`: every check gets `value`, all failures are reported at once. */
+declare const multiAssertMatchers: {
+    toPassAll<T>(received: T, checks: Matcher<T>[], options?: MultiAssertOptions): {
+        pass: boolean;
+        message: () => string;
+    };
+};
+interface ExpectLike {
+    extend(matchers: Record<string, unknown>): void;
+}
+/** Registers `toPassAll` on a Jest-compatible `expect` (Jest, Vitest, Playwright). */
+declare function installMultiAssertMatchers(expectLike: ExpectLike): void;
+declare global {
+    namespace jest {
+        interface Matchers<R, T = unknown> {
+            toPassAll(checks: Array<((received: T) => unknown) | [label: string, fn: (received: T) => unknown]>, options?: MultiAssertOptions): R;
+        }
+    }
+}
+
+export { installMultiAssertMatchers, multiAssertMatchers };