@autometa/assertions 1.0.0-rc.0

package/dist/index.js

@@ -0,0 +1,809 @@
+import { inspect } from 'node:util';
+import { equals, iterableEquality, subsetEquality } from '@jest/expect-utils';
+import { diff } from 'jest-diff';
+import { printExpected, printReceived } from 'jest-matcher-utils';
+
+// src/assertion-error.ts
+var EnsureError = class extends Error {
+  constructor(details) {
+    const formattedMessage = buildMessage(details);
+    super(formattedMessage);
+    this.name = "EnsureError";
+    this.matcher = details.matcher;
+    this.actual = details.actual;
+    this.expected = details.expected;
+  }
+};
+function buildMessage({ matcher, message, actual, expected, receivedLabel }) {
+  const parts = [message];
+  const extras = [];
+  if (typeof expected !== "undefined" && !containsSection(message, "Expected:")) {
+    extras.push(`Expected: ${formatValue(expected)}`);
+  }
+  if (typeof actual !== "undefined") {
+    const label = receivedLabel ? `Received ${receivedLabel}` : "Received";
+    if (!containsSection(message, `${label}:`)) {
+      extras.push(`${label}: ${formatValue(actual)}`);
+    }
+  }
+  if (!containsSection(message, "Matcher:")) {
+    extras.push(`Matcher: ${matcher}`);
+  }
+  if (extras.length > 0) {
+    parts.push("", ...extras);
+  }
+  return parts.join("\n");
+}
+function formatValue(value) {
+  return inspect(value, { depth: 4, maxArrayLength: 10, breakLength: 60, sorted: true });
+}
+function containsSection(message, label) {
+  return message.split("\n").some((line) => line.trimStart().startsWith(label));
+}
+var MATCHER_CALL = "ensure(received)";
+var EQUALITY_TESTERS = [iterableEquality];
+var SUBSET_TESTERS = [iterableEquality, subsetEquality];
+
+// src/core/context.ts
+function shouldFail(pass, negated) {
+  return negated ? pass : !pass;
+}
+function buildFailureMessage(matcher, baseMessage, options = {}) {
+  const sections = [`${MATCHER_CALL}.${matcher}(expected)`, baseMessage];
+  if (Object.prototype.hasOwnProperty.call(options, "expected")) {
+    sections.push(`Expected: ${printExpected(options.expected)}`);
+  }
+  if (Object.prototype.hasOwnProperty.call(options, "actual")) {
+    const label = options.actualLabel ?? "Received";
+    sections.push(`${label}: ${printReceived(options.actual)}`);
+  }
+  if (options.extra) {
+    for (const extra of options.extra) {
+      if (extra && extra.trim().length > 0) {
+        sections.push(extra);
+      }
+    }
+  }
+  if (options.diff && options.diff.trim().length > 0) {
+    sections.push(options.diff);
+  }
+  return sections.join("\n\n");
+}
+function formatDiff(expected, actual) {
+  const difference = diff(expected, actual, { expand: false });
+  return difference && difference.trim().length > 0 ? difference : void 0;
+}
+function formatMissingList(title, values) {
+  if (values.length === 0) {
+    return "";
+  }
+  const items = values.map((value) => `  - ${printExpected(value)}`).join("\n");
+  return `${title}
+${items}`;
+}
+
+// src/core/predicates.ts
+function isRecord(candidate) {
+  return typeof candidate === "object" && candidate !== null;
+}
+function isIterable(candidate) {
+  return typeof candidate?.[Symbol.iterator] === "function";
+}
+function hasLengthProperty(candidate) {
+  return typeof candidate?.length === "number";
+}
+
+// src/matchers/collections.ts
+function assertObjectContaining(ctx, shape) {
+  const isObject = isRecord(ctx.value);
+  if (!isObject) {
+    if (!ctx.negated) {
+      ctx.fail("toBeObjectContaining", {
+        message: buildFailureMessage("toBeObjectContaining", "Expected value to be an object", {
+          actual: ctx.value
+        }),
+        actual: ctx.value
+      });
+    }
+    return;
+  }
+  const pass = equals(ctx.value, shape, SUBSET_TESTERS);
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? "Expected object not to match the provided subset" : "Object does not match the provided subset";
+    ctx.fail("toBeObjectContaining", {
+      message: buildFailureMessage("toBeObjectContaining", baseMessage, {
+        expected: shape,
+        actual: ctx.value,
+        diff: formatDiff(shape, ctx.value)
+      }),
+      expected: shape,
+      actual: ctx.value
+    });
+  }
+}
+function assertArrayContaining(ctx, expected) {
+  if (!Array.isArray(ctx.value)) {
+    if (!ctx.negated) {
+      ctx.fail("toBeArrayContaining", {
+        message: buildFailureMessage("toBeArrayContaining", "Expected value to be an array", {
+          actual: ctx.value
+        }),
+        actual: ctx.value
+      });
+    }
+    return ctx.value;
+  }
+  const actual = ctx.value;
+  const missing = expected.filter(
+    (item) => !actual.some((entry) => equals(entry, item, EQUALITY_TESTERS))
+  );
+  const pass = missing.length === 0;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? "Expected array not to contain the provided elements" : "Array is missing expected elements";
+    ctx.fail("toBeArrayContaining", {
+      message: buildFailureMessage("toBeArrayContaining", baseMessage, {
+        expected,
+        actual,
+        extra: [formatMissingList("Missing elements:", missing)],
+        diff: formatDiff(expected, actual)
+      }),
+      expected,
+      actual
+    });
+  }
+  return actual;
+}
+function assertContainEqual(ctx, expected) {
+  if (!Array.isArray(ctx.value)) {
+    if (!ctx.negated) {
+      ctx.fail("toContainEqual", {
+        message: buildFailureMessage("toContainEqual", "Expected value to be an array", {
+          actual: ctx.value
+        }),
+        actual: ctx.value
+      });
+    }
+    return ctx.value;
+  }
+  const actual = ctx.value;
+  const pass = actual.some((entry) => equals(entry, expected, EQUALITY_TESTERS));
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? "Expected array not to contain the provided element" : "Array is missing the expected element";
+    ctx.fail("toContainEqual", {
+      message: buildFailureMessage("toContainEqual", baseMessage, {
+        expected,
+        actual,
+        diff: formatDiff(expected, actual)
+      }),
+      expected,
+      actual
+    });
+  }
+  return actual;
+}
+function assertIterableContaining(ctx, expected) {
+  if (!isIterable(ctx.value)) {
+    if (!ctx.negated) {
+      ctx.fail("toBeIterableContaining", {
+        message: buildFailureMessage("toBeIterableContaining", "Expected value to be iterable", {
+          actual: ctx.value
+        }),
+        actual: ctx.value
+      });
+    }
+    return ctx.value;
+  }
+  const entries = Array.from(ctx.value);
+  const missing = expected.filter(
+    (item) => !entries.some((entry) => equals(entry, item, EQUALITY_TESTERS))
+  );
+  const pass = missing.length === 0;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? "Expected iterable not to contain the provided elements" : "Iterable is missing expected elements";
+    ctx.fail("toBeIterableContaining", {
+      message: buildFailureMessage("toBeIterableContaining", baseMessage, {
+        expected,
+        actual: entries,
+        extra: [formatMissingList("Missing elements:", missing)]
+      }),
+      expected,
+      actual: entries
+    });
+  }
+  return ctx.value;
+}
+function assertHasLength(ctx, expected) {
+  if (!hasLengthProperty(ctx.value)) {
+    if (!ctx.negated) {
+      ctx.fail("toHaveLength", {
+        message: buildFailureMessage("toHaveLength", "Expected value to have a numeric length property", {
+          actual: ctx.value
+        }),
+        actual: ctx.value
+      });
+    }
+    return NaN;
+  }
+  const actualLength = ctx.value.length;
+  const pass = actualLength === expected;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected length to differ from ${expected}` : "Length does not match expectation";
+    ctx.fail("toHaveLength", {
+      message: buildFailureMessage("toHaveLength", baseMessage, {
+        expected,
+        actual: actualLength,
+        diff: formatDiff(expected, actualLength)
+      }),
+      expected,
+      actual: actualLength
+    });
+  }
+  return actualLength;
+}
+function assertToBe(ctx, expected) {
+  const pass = Object.is(ctx.value, expected);
+  if (ctx.negated ? pass : !pass) {
+    const baseMessage = ctx.negated ? "Expected values not to be strictly equal" : "Expected values to be strictly equal";
+    ctx.fail("toBe", {
+      message: buildFailureMessage("toBe", baseMessage, {
+        actual: ctx.value,
+        expected,
+        diff: formatDiff(expected, ctx.value)
+      }),
+      actual: ctx.value,
+      expected
+    });
+  }
+}
+function assertToEqual(ctx, expected) {
+  const pass = equals(ctx.value, expected, EQUALITY_TESTERS);
+  if (ctx.negated ? pass : !pass) {
+    const baseMessage = ctx.negated ? "Expected values not to be deeply equal" : "Expected values to be deeply equal";
+    ctx.fail("toEqual", {
+      message: buildFailureMessage("toEqual", baseMessage, {
+        actual: ctx.value,
+        expected,
+        diff: formatDiff(expected, ctx.value)
+      }),
+      actual: ctx.value,
+      expected
+    });
+  }
+}
+function assertToStrictEqual(ctx, expected) {
+  const pass = equals(ctx.value, expected, EQUALITY_TESTERS, true);
+  if (ctx.negated ? pass : !pass) {
+    const baseMessage = ctx.negated ? "Expected values not to be strictly equal (including prototypes and property definitions)" : "Expected values to be strictly equal (including prototypes and property definitions)";
+    ctx.fail("toStrictEqual", {
+      message: buildFailureMessage("toStrictEqual", baseMessage, {
+        actual: ctx.value,
+        expected,
+        diff: formatDiff(expected, ctx.value)
+      }),
+      actual: ctx.value,
+      expected
+    });
+  }
+}
+
+// src/matchers/instance.ts
+function assertToBeInstanceOf(ctx, ctor) {
+  if (typeof ctor !== "function") {
+    ctx.fail("toBeInstanceOf", {
+      message: buildFailureMessage("toBeInstanceOf", "Constructor must be a callable function", {
+        expected: ctor
+      }),
+      expected: ctor
+    });
+  }
+  const pass = ctx.value instanceof ctor;
+  if (ctx.negated ? pass : !pass) {
+    const label = ctor.name || "<anonymous>";
+    const baseMessage = ctx.negated ? `Expected value not to be an instance of ${label}` : `Expected value to be an instance of ${label}`;
+    ctx.fail("toBeInstanceOf", {
+      message: buildFailureMessage("toBeInstanceOf", baseMessage, {
+        expected: ctor,
+        actual: ctx.value
+      }),
+      expected: ctor,
+      actual: ctx.value
+    });
+  }
+  return ctx.value;
+}
+
+// src/matchers/nullish.ts
+var NIL_MESSAGE = "Value is null or undefined";
+function assertToBeDefined(ctx) {
+  const isDefined = ctx.value !== null && typeof ctx.value !== "undefined";
+  if (ctx.negated ? isDefined : !isDefined) {
+    const baseMessage = ctx.negated ? "Expected value to be null or undefined" : NIL_MESSAGE;
+    ctx.fail("toBeDefined", {
+      message: buildFailureMessage("toBeDefined", baseMessage, {
+        actual: ctx.value
+      }),
+      actual: ctx.value
+    });
+  }
+  return ctx.value;
+}
+function assertToBeUndefined(ctx) {
+  const isUndefined = typeof ctx.value === "undefined";
+  if (ctx.negated ? isUndefined : !isUndefined) {
+    const baseMessage = ctx.negated ? "Expected value not to be undefined" : "Expected value to be undefined";
+    ctx.fail("toBeUndefined", {
+      message: buildFailureMessage("toBeUndefined", baseMessage, {
+        actual: ctx.value
+      }),
+      actual: ctx.value
+    });
+  }
+  return void 0;
+}
+function assertToBeNull(ctx) {
+  const isNull = ctx.value === null;
+  if (ctx.negated ? isNull : !isNull) {
+    const baseMessage = ctx.negated ? "Expected value not to be null" : "Expected value to be null";
+    ctx.fail("toBeNull", {
+      message: buildFailureMessage("toBeNull", baseMessage, {
+        actual: ctx.value
+      }),
+      actual: ctx.value
+    });
+  }
+  return null;
+}
+
+// src/matchers/numeric.ts
+function requireFiniteNumber(ctx, matcher) {
+  const value = ctx.value;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    ctx.fail(matcher, {
+      message: buildFailureMessage(
+        matcher,
+        "Expected value to be a finite number",
+        { actual: value }
+      ),
+      actual: value,
+      expected: "finite number"
+    });
+  }
+  return value;
+}
+function requireFiniteExpected(ctx, matcher, expected, name = "expected") {
+  if (typeof expected !== "number" || !Number.isFinite(expected)) {
+    ctx.fail(matcher, {
+      message: buildFailureMessage(
+        matcher,
+        `Expected ${name} to be a finite number`,
+        { actual: expected }
+      ),
+      actual: expected,
+      expected: "finite number"
+    });
+  }
+}
+function assertToBeGreaterThan(ctx, expected) {
+  const actual = requireFiniteNumber(ctx, "toBeGreaterThan");
+  requireFiniteExpected(ctx, "toBeGreaterThan", expected);
+  const pass = actual > expected;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected value not to be greater than ${expected}` : `Expected value to be greater than ${expected}`;
+    ctx.fail("toBeGreaterThan", {
+      message: buildFailureMessage("toBeGreaterThan", baseMessage, {
+        expected,
+        actual
+      }),
+      actual,
+      expected
+    });
+  }
+  return actual;
+}
+function assertToBeGreaterThanOrEqual(ctx, expected) {
+  const actual = requireFiniteNumber(ctx, "toBeGreaterThanOrEqual");
+  requireFiniteExpected(
+    ctx,
+    "toBeGreaterThanOrEqual",
+    expected
+  );
+  const pass = actual >= expected;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected value not to be greater than or equal to ${expected}` : `Expected value to be greater than or equal to ${expected}`;
+    ctx.fail("toBeGreaterThanOrEqual", {
+      message: buildFailureMessage("toBeGreaterThanOrEqual", baseMessage, {
+        expected,
+        actual
+      }),
+      actual,
+      expected
+    });
+  }
+  return actual;
+}
+function assertToBeLessThan(ctx, expected) {
+  const actual = requireFiniteNumber(ctx, "toBeLessThan");
+  requireFiniteExpected(ctx, "toBeLessThan", expected);
+  const pass = actual < expected;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected value not to be less than ${expected}` : `Expected value to be less than ${expected}`;
+    ctx.fail("toBeLessThan", {
+      message: buildFailureMessage("toBeLessThan", baseMessage, {
+        expected,
+        actual
+      }),
+      actual,
+      expected
+    });
+  }
+  return actual;
+}
+function assertToBeLessThanOrEqual(ctx, expected) {
+  const actual = requireFiniteNumber(ctx, "toBeLessThanOrEqual");
+  requireFiniteExpected(
+    ctx,
+    "toBeLessThanOrEqual",
+    expected
+  );
+  const pass = actual <= expected;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected value not to be less than or equal to ${expected}` : `Expected value to be less than or equal to ${expected}`;
+    ctx.fail("toBeLessThanOrEqual", {
+      message: buildFailureMessage("toBeLessThanOrEqual", baseMessage, {
+        expected,
+        actual
+      }),
+      actual,
+      expected
+    });
+  }
+  return actual;
+}
+function assertToBeCloseTo(ctx, expected, precision = 2) {
+  const actual = requireFiniteNumber(ctx, "toBeCloseTo");
+  requireFiniteExpected(ctx, "toBeCloseTo", expected);
+  if (!Number.isInteger(precision) || precision < 0 || precision > 20) {
+    ctx.fail("toBeCloseTo", {
+      message: buildFailureMessage(
+        "toBeCloseTo",
+        "Expected precision to be an integer between 0 and 20",
+        { actual: precision }
+      ),
+      actual: precision,
+      expected: "integer between 0 and 20"
+    });
+  }
+  const tolerance = Math.pow(10, -precision) / 2;
+  const difference = Math.abs(actual - expected);
+  const epsilon = Number.EPSILON * Math.max(1, Math.abs(actual), Math.abs(expected)) * 2;
+  const pass = difference <= tolerance + epsilon;
+  if (shouldFail(pass, ctx.negated)) {
+    const baseMessage = ctx.negated ? `Expected value not to be close to ${expected} (precision ${precision})` : `Expected value to be close to ${expected} (precision ${precision})`;
+    ctx.fail("toBeCloseTo", {
+      message: buildFailureMessage("toBeCloseTo", baseMessage, {
+        expected,
+        actual,
+        extra: [
+          `Difference: ${difference}`,
+          `Tolerance: ${tolerance}`
+        ]
+      }),
+      actual,
+      expected
+    });
+  }
+  return actual;
+}
+
+// src/matchers/truthiness.ts
+function assertToBeTruthy(ctx) {
+  const pass = Boolean(ctx.value);
+  if (ctx.negated ? pass : !pass) {
+    const baseMessage = ctx.negated ? "Expected value to be falsy" : "Expected value to be truthy";
+    ctx.fail("toBeTruthy", {
+      message: buildFailureMessage("toBeTruthy", baseMessage, {
+        actual: ctx.value
+      }),
+      actual: ctx.value
+    });
+  }
+}
+function assertToBeFalsy(ctx) {
+  const pass = !ctx.value;
+  if (ctx.negated ? pass : !pass) {
+    const baseMessage = ctx.negated ? "Expected value to be truthy" : "Expected value to be falsy";
+    ctx.fail("toBeFalsy", {
+      message: buildFailureMessage("toBeFalsy", baseMessage, {
+        actual: ctx.value
+      }),
+      actual: ctx.value
+    });
+  }
+}
+
+// src/ensure.ts
+function ensure(value, options = {}) {
+  const state = {
+    value,
+    negated: false,
+    ...options.label !== void 0 ? { label: options.label } : {}
+  };
+  return new EnsureChainImpl(state);
+}
+var EnsureChainImpl = class _EnsureChainImpl {
+  constructor(state) {
+    this.state = state;
+  }
+  get value() {
+    return this.state.value;
+  }
+  get not() {
+    const toggled = !this.state.negated;
+    const nextState = {
+      value: this.state.value,
+      negated: toggled,
+      ...this.state.label !== void 0 ? { label: this.state.label } : {}
+    };
+    return new _EnsureChainImpl(
+      nextState
+    );
+  }
+  toBe(expected) {
+    assertToBe(this.createContext(), expected);
+    return this;
+  }
+  toEqual(expected) {
+    assertToEqual(this.createContext(), expected);
+    return this;
+  }
+  toStrictEqual(expected) {
+    assertToStrictEqual(this.createContext(), expected);
+    return this;
+  }
+  toBeDefined() {
+    const defined = assertToBeDefined(this.createContext());
+    const next = this.state.negated ? this : this.rewrap(defined);
+    return next;
+  }
+  toBeUndefined() {
+    const result = assertToBeUndefined(this.createContext());
+    const next = this.state.negated ? this : this.rewrap(result);
+    return next;
+  }
+  toBeNull() {
+    const result = assertToBeNull(this.createContext());
+    const next = this.state.negated ? this : this.rewrap(result);
+    return next;
+  }
+  toBeTruthy() {
+    assertToBeTruthy(this.createContext());
+    return this;
+  }
+  toBeFalsy() {
+    assertToBeFalsy(this.createContext());
+    return this;
+  }
+  toBeGreaterThan(expected) {
+    const actual = assertToBeGreaterThan(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(actual);
+    return next;
+  }
+  toBeGreaterThanOrEqual(expected) {
+    const actual = assertToBeGreaterThanOrEqual(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(actual);
+    return next;
+  }
+  toBeLessThan(expected) {
+    const actual = assertToBeLessThan(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(actual);
+    return next;
+  }
+  toBeLessThanOrEqual(expected) {
+    const actual = assertToBeLessThanOrEqual(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(actual);
+    return next;
+  }
+  toBeCloseTo(expected, precision) {
+    const actual = assertToBeCloseTo(this.createContext(), expected, precision);
+    const next = this.state.negated ? this : this.rewrap(actual);
+    return next;
+  }
+  toBeInstanceOf(ctor) {
+    const instance = assertToBeInstanceOf(this.createContext(), ctor);
+    const next = this.state.negated ? this : this.rewrap(instance);
+    return next;
+  }
+  toBeObjectContaining(shape) {
+    assertObjectContaining(this.createContext(), shape);
+    return this;
+  }
+  toBeArrayContaining(expected) {
+    const array = assertArrayContaining(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(array);
+    return next;
+  }
+  toContainEqual(expected) {
+    const array = assertContainEqual(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(array);
+    return next;
+  }
+  toBeIterableContaining(expected) {
+    const iterable = assertIterableContaining(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(iterable);
+    return next;
+  }
+  toHaveLength(expected) {
+    assertHasLength(this.createContext(), expected);
+    const next = this.state.negated ? this : this.rewrap(this.state.value);
+    return next;
+  }
+  createContext() {
+    return {
+      value: this.state.value,
+      negated: this.state.negated,
+      fail: (matcher, details) => this.fail(matcher, details),
+      ...this.state.label !== void 0 ? { label: this.state.label } : {}
+    };
+  }
+  rewrap(value) {
+    const nextState = {
+      value,
+      negated: this.state.negated,
+      ...this.state.label !== void 0 ? { label: this.state.label } : {}
+    };
+    return new _EnsureChainImpl(
+      nextState
+    );
+  }
+  fail(matcher, details) {
+    const errorDetails = {
+      matcher,
+      message: details.message,
+      ...details.actual !== void 0 ? { actual: details.actual } : {},
+      ...details.expected !== void 0 ? { expected: details.expected } : {},
+      ...this.state.label !== void 0 ? { receivedLabel: this.state.label } : {}
+    };
+    throw new EnsureError(errorDetails);
+  }
+};
+
+// src/plugins.ts
+function createEnsureFactory(ensureFn, plugins) {
+  const withAlways = (invoker, always) => {
+    Object.defineProperty(invoker, "always", {
+      value: always,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    return invoker;
+  };
+  const positiveEnsure = withAlways(ensureFn, ensureFn);
+  const pluginEntries = Object.keys(plugins).map((key) => {
+    const plugin = plugins[key];
+    if (!plugin) {
+      throw new Error(`Assertion plugin "${String(key)}" is not defined.`);
+    }
+    const factory = plugin({ ensure: positiveEnsure, isNot: false });
+    return [key, factory];
+  });
+  const negatedEnsureFn = (value, options) => {
+    return ensureFn(value, options).not;
+  };
+  const negativeEnsure = withAlways(negatedEnsureFn, ensureFn);
+  const negativePluginEntries = Object.keys(plugins).map((key) => {
+    const plugin = plugins[key];
+    if (!plugin) {
+      throw new Error(`Assertion plugin "${String(key)}" is not defined.`);
+    }
+    const factory = plugin({ ensure: negativeEnsure, isNot: true });
+    return [key, factory];
+  });
+  return (world) => {
+    const facade = (value, options) => ensureFn(value, options);
+    Object.defineProperty(facade, "world", {
+      value: world,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    for (const [key, buildFacet] of pluginEntries) {
+      const facet = buildFacet(world);
+      Object.defineProperty(facade, key, {
+        value: facet,
+        enumerable: true,
+        configurable: false,
+        writable: false
+      });
+    }
+    const notFacade = {};
+    for (const [key, buildFacet] of negativePluginEntries) {
+      const facet = buildFacet(world);
+      Object.defineProperty(notFacade, key, {
+        value: facet,
+        enumerable: true,
+        configurable: false,
+        writable: false
+      });
+    }
+    Object.defineProperty(facade, "not", {
+      value: notFacade,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+    return facade;
+  };
+}
+function createDefaultEnsureFactory() {
+  return createEnsureFactory(ensure, {});
+}
+
+// src/plugins/runtime-assertions-plugin.ts
+var runtimeAssertionsPlugin = () => ({ ensure: ensure2 }) => (world) => {
+  const defaultTableLabel = "step data table";
+  const defaultDocstringLabel = "step docstring";
+  function table(shape, options) {
+    return world.runtime.getTable(shape, options);
+  }
+  function consumeTable(shape, options) {
+    return world.runtime.consumeTable(shape, options);
+  }
+  function requireTable(shape, options) {
+    const { label, ...tableOptions } = options ?? {};
+    const table2 = consumeTable(shape, tableOptions);
+    return ensure2.always(table2, {
+      label: label ?? `Expected ${shape} ${defaultTableLabel} to be attached to the current step.`
+    }).toBeDefined().value;
+  }
+  function consumeRawTable(options) {
+    const tableInstance = consumeTable("headerless", options);
+    return tableInstance?.raw();
+  }
+  function requireRawTable(options) {
+    const { label, ...tableOptions } = options ?? {};
+    const raw = consumeRawTable(tableOptions);
+    return ensure2.always(raw, {
+      label: label ?? `Expected ${defaultTableLabel} to be attached to the current step.`
+    }).toBeDefined().value;
+  }
+  return {
+    hasTable(options) {
+      ensure2(world.runtime.hasTable, {
+        label: options?.label ?? `${defaultTableLabel} is present`
+      }).toBeTruthy();
+    },
+    hasDocstring(options) {
+      ensure2(world.runtime.hasDocstring, {
+        label: options?.label ?? `${defaultDocstringLabel} is present`
+      }).toBeTruthy();
+    },
+    docstring() {
+      return world.runtime.getDocstring();
+    },
+    consumeDocstring() {
+      return world.runtime.consumeDocstring();
+    },
+    requireDocstring(options) {
+      const docstring = world.runtime.consumeDocstring();
+      return ensure2.always(docstring, {
+        label: options?.label ?? `Expected ${defaultDocstringLabel} to be attached to the current step.`
+      }).toBeDefined().value;
+    },
+    table,
+    consumeTable,
+    requireTable,
+    rawTable() {
+      return world.runtime.getRawTable();
+    },
+    consumeRawTable,
+    requireRawTable,
+    stepMetadata() {
+      return world.runtime.getStepMetadata();
+    }
+  };
+};
+
+export { EnsureError, createDefaultEnsureFactory, createEnsureFactory, ensure, runtimeAssertionsPlugin };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map