fix: chai plugin export

dist/cjs/index.cjs

@@ -22,11 +22,253 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   SpiesGroup: () => SpiesGroup,
+  chaiSpiesPlugin: () => chaiSpiesPlugin,
   createSpiesGroup: () => createSpiesGroup,
   createSpy: () => createSpy
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/chai/chai-spies-plugin.js
+function chaiSpiesPlugin(chai, _) {
+  const Assertion = chai.Assertion;
+  Assertion.addProperty("spy", function() {
+    this.assert(
+      this._obj.__isSpy === true,
+      "expected " + this._obj + " to be a spy",
+      "expected " + this._obj + " to not be a spy"
+    );
+    return this;
+  });
+  function assertCalled(n) {
+    new Assertion(this._obj).to.be.spy;
+    const spy = this._obj;
+    if (n != void 0) {
+      this.assert(
+        spy.calls.length === n,
+        "expected " + this._obj + " to have been called #{exp} but got #{act}",
+        "expected " + this._obj + " to have not been called #{exp}",
+        n,
+        spy.calls.length
+      );
+    } else {
+      this.assert(
+        spy.called === true,
+        "expected " + this._obj + " to have been called",
+        "expected " + this._obj + " to not have been called"
+      );
+    }
+  }
+  __name(assertCalled, "assertCalled");
+  function assertCalledChain() {
+    new Assertion(this._obj).to.be.spy;
+  }
+  __name(assertCalledChain, "assertCalledChain");
+  Assertion.addChainableMethod("called", assertCalled, assertCalledChain);
+  Assertion.addProperty("once", function() {
+    new Assertion(this._obj).to.be.spy;
+    this.assert(
+      this._obj.calls.length === 1,
+      "expected " + this._obj + " to have been called once but got #{act}",
+      "expected " + this._obj + " to not have been called once",
+      1,
+      this._obj.calls.length
+    );
+  });
+  Assertion.addProperty("twice", function() {
+    new Assertion(this._obj).to.be.spy;
+    this.assert(
+      this._obj.calls.length === 2,
+      "expected " + this._obj + " to have been called twice but got #{act}",
+      "expected " + this._obj + " to not have been called twice",
+      2,
+      this._obj.calls.length
+    );
+  });
+  function nthCallWith(spy, n, expArgs) {
+    if (spy.calls.length <= n) return false;
+    const actArgs = spy.calls[n].args;
+    if (actArgs.length !== expArgs.length) return false;
+    for (let i = 0; i < expArgs.length; i++) {
+      if (!_.eql(actArgs[i], expArgs[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  __name(nthCallWith, "nthCallWith");
+  function numberOfCallsWith(spy, expArgs) {
+    let found = 0;
+    const calls = spy.calls;
+    for (let i = 0; i < calls.length; i++) {
+      if (nthCallWith(spy, i, expArgs)) {
+        found++;
+      }
+    }
+    return found;
+  }
+  __name(numberOfCallsWith, "numberOfCallsWith");
+  Assertion.addProperty("first", function() {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy nth call with", 1);
+    }
+  });
+  Assertion.addProperty("second", function() {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy nth call with", 2);
+    }
+  });
+  Assertion.addProperty("third", function() {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy nth call with", 3);
+    }
+  });
+  Assertion.addProperty("on");
+  Assertion.addChainableMethod("nth", function(n) {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy nth call with", n);
+    }
+  });
+  function generateOrdinalNumber(n) {
+    if (n === 1) return "first";
+    if (n === 2) return "second";
+    if (n === 3) return "third";
+    return n + "th";
+  }
+  __name(generateOrdinalNumber, "generateOrdinalNumber");
+  function assertWith() {
+    new Assertion(this._obj).to.be.spy;
+    const expArgs = [].slice.call(arguments, 0), spy = this._obj, calls = spy.calls, always = _.flag(this, "spy always"), nthCall = _.flag(this, "spy nth call with");
+    if (always) {
+      const passed = numberOfCallsWith(spy, expArgs);
+      this.assert(
+        arguments.length ? calls.length && passed === calls.length : calls.length === 0,
+        "expected " + this._obj + " to have been always called with #{exp} but got " + passed + " out of " + calls.length,
+        "expected " + this._obj + " to have not always been called with #{exp}",
+        expArgs
+      );
+    } else if (nthCall) {
+      const ordinalNumber = generateOrdinalNumber(nthCall), actArgs = calls[nthCall - 1];
+      new Assertion(this._obj).to.be.have.been.called.min(nthCall);
+      this.assert(
+        nthCallWith(spy, nthCall - 1, expArgs),
+        "expected " + this._obj + " to have been called at the " + ordinalNumber + " time with #{exp} but got #{act}",
+        "expected " + this._obj + " to have not been called at the " + ordinalNumber + " time with #{exp}",
+        expArgs,
+        actArgs
+      );
+    } else {
+      const passed = numberOfCallsWith(spy, expArgs);
+      this.assert(
+        passed > 0,
+        "expected " + this._obj + " to have been called with #{exp}",
+        "expected " + this._obj + " to have not been called with #{exp} but got " + passed + " times",
+        expArgs
+      );
+    }
+  }
+  __name(assertWith, "assertWith");
+  function assertWithChain() {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy with", true);
+    }
+  }
+  __name(assertWithChain, "assertWithChain");
+  Assertion.addChainableMethod("with", assertWith, assertWithChain);
+  Assertion.addProperty("always", function() {
+    if (this._obj.__isSpy) {
+      _.flag(this, "spy always", true);
+    }
+  });
+  Assertion.addMethod("exactly", function() {
+    new Assertion(this._obj).to.be.spy;
+    const args = [].slice.call(arguments, 0);
+    this.assert(
+      this._obj.calls.length === args[0],
+      "expected " + this._obj + " to have been called #{exp} times but got #{act}",
+      "expected " + this._obj + " to not have been called #{exp} times",
+      args[0],
+      this._obj.calls.length
+    );
+  });
+  function above(_super) {
+    return function(n) {
+      if (this._obj.__isSpy) {
+        new Assertion(this._obj).to.be.spy;
+        this.assert(
+          this._obj.calls.length > n,
+          "expected " + this._obj + " to have been called more than #{exp} times but got #{act}",
+          "expected " + this._obj + " to have been called at most #{exp} times but got #{act}",
+          n,
+          this._obj.calls.length
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  }
+  __name(above, "above");
+  Assertion.overwriteMethod("above", above);
+  Assertion.overwriteMethod("gt", above);
+  function below(_super) {
+    return function(n) {
+      if (this._obj.__isSpy) {
+        new Assertion(this._obj).to.be.spy;
+        this.assert(
+          this._obj.calls.length < n,
+          "expected " + this._obj + " to have been called fewer than #{exp} times but got #{act}",
+          "expected " + this._obj + " to have been called at least #{exp} times but got #{act}",
+          n,
+          this._obj.calls.length
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  }
+  __name(below, "below");
+  Assertion.overwriteMethod("below", below);
+  Assertion.overwriteMethod("lt", below);
+  function min(_super) {
+    return function(n) {
+      if (this._obj.__isSpy) {
+        new Assertion(this._obj).to.be.spy;
+        this.assert(
+          this._obj.calls.length >= n,
+          "expected " + this._obj + " to have been called at least #{exp} times but got #{act}",
+          "expected " + this._obj + " to have been called fewer than #{exp} times but got #{act}",
+          n,
+          this._obj.calls.length
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  }
+  __name(min, "min");
+  Assertion.overwriteMethod("min", min);
+  Assertion.overwriteMethod("least", min);
+  function max(_super) {
+    return function(n) {
+      if (this._obj.__isSpy) {
+        new Assertion(this._obj).to.be.spy;
+        this.assert(
+          this._obj.calls.length <= n,
+          "expected " + this._obj + " to have been called at most #{exp} times but got #{act}",
+          "expected " + this._obj + " to have been called more than #{exp} times but got #{act}",
+          n,
+          this._obj.calls.length
+        );
+      } else {
+        _super.apply(this, arguments);
+      }
+    };
+  }
+  __name(max, "max");
+  Assertion.overwriteMethod("max", max);
+  Assertion.overwriteMethod("most", max);
+}
+__name(chaiSpiesPlugin, "chaiSpiesPlugin");
+
 // src/create-spy.js
 function _parseSpyArgs(target, methodNameOrImpl, customImplForMethod) {
   let originalFn;
@@ -217,6 +459,7 @@ __name(createSpiesGroup, "createSpiesGroup");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SpiesGroup,
+  chaiSpiesPlugin,
   createSpiesGroup,
   createSpy
 });

src/chai/index.d.ts

@@ -0,0 +1 @@
+export * from './chai-spies-plugin.js';

src/index.d.ts

@@ -1,2 +1,3 @@
+export * from './chai/index.js';
 export * from './create-spy.js';
 export * from './create-spies-group.js';

src/index.js

@@ -1,2 +1,3 @@
+export * from './chai/index.js';
 export * from './create-spy.js';
 export * from './create-spies-group.js';