@magic/types 0.1.23 → 0.1.26

package/README.md

@@ -329,6 +329,20 @@ update dependencies
 - update dev dependencies
 - update docs
 
-##### 0.1.24 - unreleased
+##### 0.1.24
+
+- update dependencies
+
+##### 0.1.25
+
+- add typescript types
+- coverage is 100%
+- update dependencies
+
+##### 0.1.26
+
+- fix typescript d.ts files
+
+##### 0.0.27 - unreleased
 
 ...

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@magic/types",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "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 && 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,28 +23,32 @@
     "calls": "calls"
   },
   "engines": {
-    "node": ">=14.15.4"
+    "node": ">=18"
   },
   "engineStrict": true,
   "repository": {
     "type": "git",
-    "url": "https://github.com/magic/types"
+    "url": "git+https://github.com/magic/types.git"
   },
   "bugs": {
     "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.8",
-    "@magic-modules/pre": "0.0.11",
-    "@magic-themes/docs": "0.0.14",
-    "@magic/core": "0.0.149",
-    "@magic/format": "0.0.50",
-    "@magic/test": "0.2.15"
+    "@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