tutuca 0.9.71 → 0.9.72

package/dist/tutuca-cli.js

@@ -12831,6 +12831,111 @@ var init_chai = __esm(() => {
   __name(use, "use");
 });
 
+// src/chai-jest.js
+function jestMatchers(chai, utils) {
+  const A = chai.Assertion;
+  const m = (name, fn) => A.addMethod(name, fn);
+  m("toBe", function(expected) {
+    this.assert(Object.is(this._obj, expected), "expected #{this} to be #{exp}", "expected #{this} not to be #{exp}", expected, this._obj);
+  });
+  m("toEqual", function(expected) {
+    this.assert(utils.eql(this._obj, expected), "expected #{this} to deeply equal #{exp}", "expected #{this} not to deeply equal #{exp}", expected, this._obj, true);
+  });
+  m("toBeTruthy", function() {
+    this.assert(Boolean(this._obj), "expected #{this} to be truthy", "expected #{this} not to be truthy");
+  });
+  m("toBeFalsy", function() {
+    this.assert(!this._obj, "expected #{this} to be falsy", "expected #{this} not to be falsy");
+  });
+  m("toBeNull", function() {
+    this.assert(this._obj === null, "expected #{this} to be null", "expected #{this} not to be null");
+  });
+  m("toBeUndefined", function() {
+    this.assert(this._obj === undefined, "expected #{this} to be undefined", "expected #{this} not to be undefined");
+  });
+  m("toBeDefined", function() {
+    this.assert(this._obj !== undefined, "expected #{this} to be defined", "expected #{this} to be undefined");
+  });
+  m("toBeNaN", function() {
+    this.assert(Number.isNaN(this._obj), "expected #{this} to be NaN", "expected #{this} not to be NaN");
+  });
+  const compare = (name, op, word) => m(name, function(expected) {
+    this.assert(op(this._obj, expected), `expected #{this} to be ${word} #{exp}`, `expected #{this} not to be ${word} #{exp}`, expected);
+  });
+  compare("toBeGreaterThan", (a, b) => a > b, "greater than");
+  compare("toBeGreaterThanOrEqual", (a, b) => a >= b, "greater than or equal to");
+  compare("toBeLessThan", (a, b) => a < b, "less than");
+  compare("toBeLessThanOrEqual", (a, b) => a <= b, "less than or equal to");
+  m("toBeCloseTo", function(expected, numDigits = 2) {
+    const pass = Math.abs(expected - this._obj) < 10 ** -numDigits / 2;
+    this.assert(pass, `expected #{this} to be close to #{exp} (${numDigits} digits)`, `expected #{this} not to be close to #{exp} (${numDigits} digits)`, expected);
+  });
+  m("toContain", function(item) {
+    const obj = this._obj;
+    const ok = typeof obj === "string" ? obj.includes(item) : Array.from(obj).includes(item);
+    this.assert(ok, "expected #{this} to contain #{exp}", "expected #{this} not to contain #{exp}", item);
+  });
+  m("toHaveLength", function(length) {
+    const actual = this._obj == null ? undefined : this._obj.length;
+    this.assert(actual === length, "expected #{this} to have length #{exp}", "expected #{this} not to have length #{exp}", length, actual);
+  });
+  m("toMatch", function(expected) {
+    const obj = this._obj;
+    const ok = expected instanceof RegExp ? expected.test(obj) : String(obj).includes(expected);
+    this.assert(ok, "expected #{this} to match #{exp}", "expected #{this} not to match #{exp}", expected);
+  });
+  m("toHaveProperty", function(path, ...rest) {
+    const keys = Array.isArray(path) ? path : String(path).split(".");
+    let cur = this._obj;
+    let found = true;
+    for (const k of keys) {
+      if (cur != null && k in Object(cur))
+        cur = cur[k];
+      else {
+        found = false;
+        break;
+      }
+    }
+    const pass = found && (rest.length === 0 || utils.eql(cur, rest[0]));
+    this.assert(pass, "expected #{this} to have property #{exp}", "expected #{this} not to have property #{exp}", path);
+  });
+  m("toBeInstanceOf", function(ctor) {
+    this.assert(this._obj instanceof ctor, "expected #{this} to be an instance of #{exp}", "expected #{this} not to be an instance of #{exp}", ctor.name ?? ctor);
+  });
+  m("toThrow", function(expected) {
+    const a = new chai.Assertion(this._obj);
+    if (utils.flag(this, "negate")) {
+      expected === undefined ? a.to.not.throw() : a.to.not.throw(expected);
+    } else {
+      expected === undefined ? a.to.throw() : a.to.throw(expected);
+    }
+  });
+}
+var JEST_MATCHERS;
+var init_chai_jest = __esm(() => {
+  JEST_MATCHERS = [
+    "toBe",
+    "toEqual",
+    "toBeTruthy",
+    "toBeFalsy",
+    "toBeNull",
+    "toBeUndefined",
+    "toBeDefined",
+    "toBeNaN",
+    "toBeGreaterThan",
+    "toBeGreaterThanOrEqual",
+    "toBeLessThan",
+    "toBeLessThanOrEqual",
+    "toBeCloseTo",
+    "toContain",
+    "toHaveLength",
+    "toMatch",
+    "toHaveProperty",
+    "toBeInstanceOf",
+    "toThrow"
+  ];
+});
+
 // tools/core/results.js
 class ModuleInfo {
   constructor({ path = null, present = new Set, counts = {}, warnings = [] }) {
@@ -14743,12 +14848,14 @@ function parseLimit(raw) {
 var COMMANDS;
 var init__registry = __esm(() => {
   init_chai();
+  init_chai_jest();
   init_describe();
   init_docs();
   init_list();
   init_lint();
   init_render2();
   init_test();
+  use(jestMatchers);
   COMMANDS = {
     get: {
       describe: "Summarize the module's exports and counts.",
@@ -15618,6 +15725,7 @@ init__registry();
 init_feedback();
 
 // tools/cli/commands/help.js
+init_chai_jest();
 var exports_help = {};
 __export(exports_help, {
   run: () => run4,
@@ -15670,7 +15778,9 @@ MODULE CONVENTION
         describe(title, fn)               // untagged
         describe(title, { component }, fn)// explicit tag with custom title
       and   test(title, fn)               // fn may be async
-      and   expect comes from chai
+      and   expect is chai, with jest-style matchers added:
+            ${JEST_MATCHERS.join(", ")}
+            (chai's BDD chain like .to.equal also works; use .not to negate)
 
     export function getRoot()             // optional; returned by info