@magic/types 0.1.22 → 0.1.25

package/README.md

@@ -23,11 +23,13 @@ typechecking utilities
 [snyk-url]: https://snyk.io/test/github/magic/types
 
 ##### install
+
 ```javascript
 npm install @magic/types
 ```
 
 ##### import single function
+
 ```js
 // single function import
 import { isArray } from '@magic/types'
@@ -36,6 +38,7 @@ isArray([]) // true
 ```
 
 ##### import all functions
+
 ```javascript
 import is from '@magic/types'
 
@@ -43,6 +46,7 @@ is.array([]) // true
 ```
 
 ##### functions
+
 ```javascript
 
 // comparisons
@@ -208,93 +212,133 @@ isOwnProp({ test: undefined }, 'test') // true
 // alias isOwnProperty, is.ownProperty, is.ownProp, is.prop
 ```
 
-
 #### Changelog
 
 ##### 0.0.5
+
 added Map, WeakMap, Set and WeakSet
 
 ##### 0.1.0
+
 use es6 modules
 
 ##### 0.1.1
+
 FIX: add module field to package.json
 
 ##### 0.1.2
+
 FIX: is.number no longer errors on node es6 modules and other weird objects
 
 ##### 0.1.3
+
 use @magic/deep for is.deep.equal and is.deep.different
 
 ##### 0.1.4
+
 is.deep uses @magic/deep now.
 
 this means that is.deep.equal(null, undefined) is returning a function now,
 because it expects currying.
 
 ##### 0.1.5
+
 minimum node version is 13.5.0
 
 ##### 0.1.6
+
 remove @magic/deep dependency
 
 ##### 0.1.7
+
 fix erroneous '@magic/types' import in src/deep/equal.mjs
 
 ##### 0.1.8
+
 add
-* is.every
-* is.some
-* is.none
+
+- is.every
+- is.some
+- is.none
 
 ##### 0.1.9
+
 add is.instanceOf
 
 ##### 0.1.10
+
 add isCase, isUpperCase, isLowerCase
 
 ##### 0.1.11
+
 add isObjectNative
 
 ##### 0.1.12
+
 bump required node version to 14.2.0
 
 ##### 0.1.13
-* add isAsyncFunction
-* add isGeneratorFunction
+
+- add isAsyncFunction
+- add isGeneratorFunction
 
 ##### 0.1.14
-* bump required node version to 14.15.4
-* update dependencies
+
+- bump required node version to 14.15.4
+- update dependencies
 
 ##### 0.1.15
+
 deep.equal now does return true for objects that have undefined property values
 
 ##### 0.1.16
-* remove circular dependencies
+
+- remove circular dependencies
 
 ##### 0.1.17
-* add isSameType, isSame, same, sameType
-* update dev dependencies
+
+- add isSameType, isSame, same, sameType
+- update dev dependencies
 
 ##### 0.1.18
-* add isModule and isOwnProperty
-* update dependencies
+
+- add isModule and isOwnProperty
+- update dependencies
 
 ##### 0.1.19
+
 update dependencies
 
 ##### 0.1.20
+
 update dependencies
 
 ##### 0.1.21
-* isBuffer uses Buffer.isBuffer.
-* update dependencies
-* getLength does not use .length or .size property for unknown types. instead we test for is.array, is.string, is.map etc.
+
+- isBuffer uses Buffer.isBuffer.
+- update dependencies
+- getLength does not use .length or .size property for unknown types. instead we test for is.array, is.string, is.map etc.
 
 ##### 0.1.22
-* update getLength to correctly return the length of buffers (regressed in 0.1.21).
-* add a test case for buffer length
 
-##### 0.1.23 - unreleased
+- update getLength to correctly return the length of buffers (regressed in 0.1.21).
+- add a test case for buffer length
+
+##### 0.1.23
+
+- update dev dependencies
+- update docs
+
+##### 0.1.24
+
+- update dependencies
+
+##### 0.1.25
+
+- add typescript types
+- coverage is 100%
+- update dependencies
+
+##### 0.1.26 - unreleased
+
 ...

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@magic/types",
-  "version": "0.1.22",
+  "version": "0.1.25",
   "author": "Wizards & Witches",
   "homepage": "https://github.com/magic/types",
   "license": "AGPL-3.0",
   "description": "typechecking library",
-  "main": "src/index.mjs",
+  "main": "src/index.js",
+  "types": "./types/index.d.ts",
   "type": "module",
   "scripts": {
     "start": "t",
-    "build": "NODE_ENV=production magic build",
+    "build": "tsc && node scripts/strip-js-extension.js && npm run format && echo 'Types generated in dist/*'",
+    "prepublishOnly": "npm run build",
+    "build:docs": "NODE_ENV=production magic build",
     "prod": "NODE_ENV=production magic build serve",
     "clean": "magic clean",
     "serve": "magic serve",
@@ -20,7 +23,7 @@
     "calls": "calls"
   },
   "engines": {
-    "node": ">=14.15.4"
+    "node": ">=18"
   },
   "engineStrict": true,
   "repository": {
@@ -31,17 +34,21 @@
     "url": "https://github.com/magic/types/issues"
   },
   "files": [
-    "src"
+    "src",
+    "types"
   ],
   "devDependencies": {
     "@magic-modules/git-badges": "0.0.12",
-    "@magic-modules/light-switch": "0.0.11",
-    "@magic-modules/no-spy": "0.0.7",
-    "@magic-modules/pre": "0.0.11",
-    "@magic-themes/docs": "0.0.14",
-    "@magic/core": "0.0.141",
-    "@magic/format": "0.0.40",
-    "@magic/test": "0.2.11"
+    "@magic-modules/light-switch": "0.0.12",
+    "@magic-modules/no-spy": "0.0.9",
+    "@magic-modules/pre": "0.0.12",
+    "@magic-themes/docs": "0.0.15",
+    "@magic/core": "0.0.156",
+    "@magic/format": "0.0.68",
+    "@magic/fs": "0.0.31",
+    "@magic/test": "0.2.20",
+    "@types/node": "24.5.2",
+    "typescript": "5.9.2"
   },
   "keywords": [
     "magic",

package/src/deep/different.js

@@ -0,0 +1,33 @@
+import is from '../lib.js'
+
+import equal from './equal.js'
+
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+/**
+ * @param {unknown} a
+ * @param {unknown} [b]
+ * @returns {boolean | ((c: unknown) => boolean)}
+ */
+export const different = (a, b) => {
+  if (is.undefined(b)) {
+    if (is.undefined(a)) {
+      return false
+    }
+
+    return c => different(a, c)
+  }
+
+  return !equal(a, b)
+}
+
+export default different

package/src/deep/equal.js

@@ -0,0 +1,146 @@
+// Written by Substack <3
+
+import is from '../lib.js'
+
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+/**
+ * @param {unknown} a
+ * @param {unknown} [b]
+ * @returns {boolean | ((c: unknown) => boolean)}
+ */
+export const equal = (a, b) => {
+  // curry
+  if (is.undefined(b)) {
+    if (is.undefined(a)) {
+      return true
+    }
+
+    return c => equal(a, c)
+  }
+
+  if (is.null(b)) {
+    return a === b
+  }
+
+  // types must match
+  if (typeof a !== typeof b) {
+    return false
+  }
+
+  // bool, string, number, falsy values
+  if (is.comparable(a) || is.comparable(b)) {
+    return a === b
+  }
+
+  // if (is.arguments(a)) {
+  //  return is.length.eq(a, b)
+  // }
+
+  // Check if both are objects before accessing prototype
+  if (!is.object(a) || !is.object(b)) {
+    return a === b
+  }
+
+  // identical 'prototype' property.
+  if ('prototype' in a && 'prototype' in b) {
+    return a.prototype === b.prototype
+  }
+
+  // real types must match too
+  // if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
+  //   return false
+  // }
+
+  // dates
+  if (is.date(a)) {
+    return a === b
+  }
+
+  /* functions are handled by prototype comparison above */
+  // if (is.function(a)) {
+  //   if (!is.function(b)) {
+  //     return false
+  //   }
+
+  //   return a.toString() === b.toString()
+  // }
+
+  // buffers
+  if (is.buffer(a)) {
+    if (!is.buffer(b)) {
+      return false
+    }
+
+    if (a.length !== b.length) {
+      return false
+    }
+
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  if (is.objectNative(a) || is.array(a)) {
+    if (is.array(a)) {
+      if (!is.array(b)) {
+        return false
+      }
+
+      return !a.some((v, i) => v !== b[i])
+    }
+
+    if (!is.objectNative(b)) {
+      return false
+    }
+
+    const aObj = a
+    const bObj = b
+
+    const ka = Object.keys(aObj)
+    const kb = Object.keys(bObj)
+
+    // having the same number of owned properties (keys incorporates hasOwnProperty)
+    if (ka.length !== kb.length) {
+      return false
+    }
+
+    ka.sort()
+    kb.sort()
+
+    // ~~~cheap key test
+    for (let i = 0; i < ka.length; i++) {
+      if (ka[i] !== kb[i]) {
+        return false
+      }
+    }
+
+    // equivalent values for every corresponding key, and
+    // ~~~possibly expensive deep test
+    let key
+    for (let i = ka.length - 1; i >= 0; i--) {
+      key = ka[i]
+
+      if (!equal(aObj[key], bObj[key])) {
+        return false
+      }
+    }
+  }
+
+  return typeof a === typeof b
+}
+
+export default equal

package/src/deep/{index.mjs → index.js}

@@ -1,5 +1,5 @@
-import { equal } from './equal.mjs'
-import { different } from './different.mjs'
+import { equal } from './equal.js'
+import { different } from './different.js'
 
 export const isDeepEqual = equal
 export const deepEqual = equal