Inline type-detect as a simple function

README.md

@@ -145,7 +145,6 @@ Chai offers a robust Plugin architecture for extending Chai's assertions and int
 - [chaijs / chai-docs](https://github.com/chaijs/chai-docs): The chaijs.com website source code.
 - [chaijs / assertion-error](https://github.com/chaijs/assertion-error): Custom `Error` constructor thrown upon an assertion failing.
 - [chaijs / deep-eql](https://github.com/chaijs/deep-eql): Improved deep equality testing for Node.js and the browser.
-- [chaijs / type-detect](https://github.com/chaijs/type-detect): Improved typeof detection for Node.js and the browser.
 - [chaijs / check-error](https://github.com/chaijs/check-error): Error comparison and information related utility for Node.js and the browser.
 - [chaijs / loupe](https://github.com/chaijs/loupe): Inspect utility for Node.js and browsers.
 - [chaijs / pathval](https://github.com/chaijs/pathval): Object value retrieval given a string path.

karma.conf.cjs

@@ -5,6 +5,7 @@ module.exports = function(config) {
         { pattern: 'chai.js', type: 'module', included: false, served: true }
       , { pattern: 'test/bootstrap/index.js', type: 'module'}
       , { pattern: 'test/*.js', type: 'module' }
+      , { pattern: 'test/type-detect/*.js', type: 'module' }
       ]
     , reporters: [ 'progress' ]
     , colors: true

lib/chai/core/assertions.js

@@ -243,8 +243,8 @@ Assertion.addProperty('all', function () {
  * ### .a(type[, msg])
  *
  * Asserts that the target's type is equal to the given string `type`. Types
- * are case insensitive. See the `type-detect` project page for info on the
- * type detection algorithm: https://github.com/chaijs/type-detect.
+ * are case insensitive. See the utility file `./type-detect.js` for info on the
+ * type detection algorithm.
  *
  *     expect('foo').to.be.a('string');
  *     expect({a: 1}).to.be.an('object');

lib/chai/utils/expectTypes.js

@@ -20,7 +20,7 @@
 
 import AssertionError from 'assertion-error';
 import {flag} from './flag.js';
-import {default as type} from 'type-detect';
+import {type} from './type-detect.js';
 
 export function expectTypes(obj, types) {
   var flagMsg = flag(obj, 'message');

lib/chai/utils/getOperator.js

@@ -1,10 +1,9 @@
 import {flag} from './flag.js';
-import type from 'type-detect';
-
+import {type} from './type-detect.js';
 
 function isObjectType(obj) {
   var objectType = type(obj);
-  var objectTypes = ['Array', 'Object', 'function'];
+  var objectTypes = ['Array', 'Object', 'Function'];
 
   return objectTypes.indexOf(objectType) !== -1;
 }

lib/chai/utils/index.js

@@ -20,7 +20,7 @@ export {test} from './test.js';
  * type utility
  */
 
-export {default as type} from 'type-detect';
+export {type} from './type-detect.js';
 
 /*!
  * expectTypes utility

lib/chai/utils/type-detect.js

@@ -0,0 +1,16 @@
+export function type(obj) {
+  if (typeof obj === 'undefined') {
+    return 'undefined';
+  }
+
+  if (obj === null) {
+    return 'null';
+  }
+
+  const stringTag = obj[Symbol.toStringTag];
+  if (typeof stringTag === 'string') {
+    return stringTag;
+  }
+  const type = Object.prototype.toString.call(obj).slice(8, -1);
+  return type;
+}

package.json

@@ -47,8 +47,7 @@
     "check-error": "^2.0.0",
     "deep-eql": "^5.0.0",
     "loupe": "^2.3.1",
-    "pathval": "^2.0.0",
-    "type-detect": "^4.0.5"
+    "pathval": "^2.0.0"
   },
   "devDependencies": {
     "bump-cli": "^1.1.3",

test/assert.js

@@ -171,19 +171,19 @@ describe('assert', function () {
 
     err(function(){
       assert.instanceOf(new Foo(), 1, 'blah');
-    }, "blah: The instanceof assertion needs a constructor but number was given.");
+    }, "blah: The instanceof assertion needs a constructor but Number was given.");
 
     err(function(){
       assert.instanceOf(new Foo(), 'batman');
-    }, "The instanceof assertion needs a constructor but string was given.");
+    }, "The instanceof assertion needs a constructor but String was given.");
 
     err(function(){
       assert.instanceOf(new Foo(), {});
     }, "The instanceof assertion needs a constructor but Object was given.");
 
     err(function(){
       assert.instanceOf(new Foo(), true);
-    }, "The instanceof assertion needs a constructor but boolean was given.");
+    }, "The instanceof assertion needs a constructor but Boolean was given.");
 
     err(function(){
       assert.instanceOf(new Foo(), null);
@@ -198,12 +198,12 @@ describe('assert', function () {
       var t = new Thing();
       Thing.prototype = 1337;
       assert.instanceOf(t, Thing);
-    }, 'The instanceof assertion needs a constructor but function was given.', true);
+    }, 'The instanceof assertion needs a constructor but Function was given.', true);
 
     if (typeof Symbol !== 'undefined' && typeof Symbol.hasInstance !== 'undefined') {
         err(function(){
           assert.instanceOf(new Foo(), Symbol());
-        }, "The instanceof assertion needs a constructor but symbol was given.");
+        }, "The instanceof assertion needs a constructor but Symbol was given.");
 
         err(function() {
             var FakeConstructor = {};
@@ -233,19 +233,19 @@ describe('assert', function () {
 
     err(function(){
       assert.notInstanceOf(new Foo(), 1, 'blah');
-    }, "blah: The instanceof assertion needs a constructor but number was given.");
+    }, "blah: The instanceof assertion needs a constructor but Number was given.");
 
     err(function(){
       assert.notInstanceOf(new Foo(), 'batman');
-    }, "The instanceof assertion needs a constructor but string was given.");
+    }, "The instanceof assertion needs a constructor but String was given.");
 
     err(function(){
       assert.notInstanceOf(new Foo(), {});
     }, "The instanceof assertion needs a constructor but Object was given.");
 
     err(function(){
       assert.notInstanceOf(new Foo(), true);
-    }, "The instanceof assertion needs a constructor but boolean was given.");
+    }, "The instanceof assertion needs a constructor but Boolean was given.");
 
     err(function(){
       assert.notInstanceOf(new Foo(), null);
@@ -258,7 +258,7 @@ describe('assert', function () {
     if (typeof Symbol !== 'undefined' && typeof Symbol.hasInstance !== 'undefined') {
         err(function(){
           assert.notInstanceOf(new Foo(), Symbol());
-        }, "The instanceof assertion needs a constructor but symbol was given.");
+        }, "The instanceof assertion needs a constructor but Symbol was given.");
 
         err(function() {
             var FakeConstructor = {};

test/bootstrap/index.js

@@ -30,7 +30,7 @@ if (typeof Error.captureStackTrace !== 'undefined') {
  */
 
 globalThis.err = function globalErr (fn, val, skipStackTest) {
-  if (chai.util.type(fn) !== 'function')
+  if (chai.util.type(fn) !== 'Function')
     throw new chai.AssertionError('Invalid fn');
 
   try {

test/expect.js

@@ -403,23 +403,23 @@ describe('expect', function () {
 
     err(function(){
       expect(new Foo()).to.an.instanceof(1, 'blah');
-    }, "blah: The instanceof assertion needs a constructor but number was given.");
+    }, "blah: The instanceof assertion needs a constructor but Number was given.");
 
     err(function(){
       expect(new Foo(), 'blah').to.an.instanceof(1);
-    }, "blah: The instanceof assertion needs a constructor but number was given.");
+    }, "blah: The instanceof assertion needs a constructor but Number was given.");
 
     err(function(){
       expect(new Foo()).to.an.instanceof('batman');
-    }, "The instanceof assertion needs a constructor but string was given.");
+    }, "The instanceof assertion needs a constructor but String was given.");
 
     err(function(){
       expect(new Foo()).to.an.instanceof({});
     }, "The instanceof assertion needs a constructor but Object was given.");
 
     err(function(){
       expect(new Foo()).to.an.instanceof(true);
-    }, "The instanceof assertion needs a constructor but boolean was given.");
+    }, "The instanceof assertion needs a constructor but Boolean was given.");
 
     err(function(){
       expect(new Foo()).to.an.instanceof(null);
@@ -434,12 +434,12 @@ describe('expect', function () {
       var t = new Thing();
       Thing.prototype = 1337;
       expect(t).to.an.instanceof(Thing);
-    }, 'The instanceof assertion needs a constructor but function was given.', true)
+    }, 'The instanceof assertion needs a constructor but Function was given.', true)
 
     if (typeof Symbol !== 'undefined' && typeof Symbol.hasInstance !== 'undefined') {
         err(function(){
           expect(new Foo()).to.an.instanceof(Symbol());
-        }, "The instanceof assertion needs a constructor but symbol was given.");
+        }, "The instanceof assertion needs a constructor but Symbol was given.");
 
         err(function() {
             var FakeConstructor = {};

test/should.js

@@ -468,19 +468,19 @@ describe('should', function() {
 
     err(function(){
       new Foo().should.be.an.instanceof(1, 'blah');
-    }, "blah: The instanceof assertion needs a constructor but number was given.");
+    }, "blah: The instanceof assertion needs a constructor but Number was given.");
 
     err(function(){
       new Foo().should.be.an.instanceof('batman');
-    }, "The instanceof assertion needs a constructor but string was given.");
+    }, "The instanceof assertion needs a constructor but String was given.");
 
     err(function(){
       new Foo().should.be.an.instanceof({});
     }, "The instanceof assertion needs a constructor but Object was given.");
 
     err(function(){
       new Foo().should.be.an.instanceof(true);
-    }, "The instanceof assertion needs a constructor but boolean was given.");
+    }, "The instanceof assertion needs a constructor but Boolean was given.");
 
     err(function(){
       new Foo().should.be.an.instanceof(null);
@@ -495,12 +495,12 @@ describe('should', function() {
       var t = new Thing();
       Thing.prototype = 1337;
       t.should.be.an.instanceof(Thing);
-    }, 'The instanceof assertion needs a constructor but function was given.', true);
+    }, 'The instanceof assertion needs a constructor but Function was given.', true);
 
     if (typeof Symbol !== 'undefined' && typeof Symbol.hasInstance !== 'undefined') {
         err(function(){
           new Foo().should.be.an.instanceof(Symbol());
-        }, "The instanceof assertion needs a constructor but symbol was given.");
+        }, "The instanceof assertion needs a constructor but Symbol was given.");
 
         err(function() {
             var FakeConstructor = {};

test/type-detect/deno-test.ts

@@ -0,0 +1,7 @@
+/* global Deno:readonly */
+// @ts-nocheck
+import { assertEquals } from 'https://deno.land/std/testing/asserts.ts';
+import typeDetect from '../index.ts';
+Deno.test('type detect works', () => {
+  assertEquals(typeDetect('hello'), 'string');
+});