@magic/types 0.1.27 → 0.1.29

package/README.md

@@ -176,6 +176,12 @@ isDeepEqual([1, 2, 3], [1, 2, 3]) // true
 isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
 // alias is.deep.diff, is.deep.different
 
+isDeepEqual([1, 2, 3], [3, 2, 1]) // true
+isDeepEqual([1, 2, 3], [3, 2, 1], { strict: true }) // false
+
+isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }) // true
+isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }, { strict: true }) // false
+
 isEvery([1, 2, 3], 'number') // true
 isEvery([1, 2, 3], is.number) // true
 // alias is.every, is.all
@@ -210,6 +216,7 @@ isModule(mod) // true
 
 isOwnProp({ test: undefined }, 'test') // true
 // alias isOwnProperty, is.ownProperty, is.ownProp, is.prop
+
 ```
 
 #### Changelog
@@ -348,6 +355,15 @@ update dependencies
 - @types/node is a dependency, not devDependency
 - update dependencies
 
-##### 0.1.28 - unreleased
+##### 0.1.28
+
+- options.strict makes the tests include sort order of objects and array, [1, 2] is [2, 1] if options.strict = true
+- update dependencies
+
+##### 0.1.29
+
+- change types of is.ln, is.len, is.length and is.count to reflect their type as function with subfunctions
+
+##### 0.1.30 - unreleased
 
 ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/types",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "author": "Wizards & Witches",
   "homepage": "https://github.com/magic/types",
   "license": "AGPL-3.0",
@@ -10,8 +10,8 @@
   "type": "module",
   "scripts": {
     "start": "t",
-    "build": "tsc && npm run format && echo 'Types generated in dist/*'",
-    "prepublishOnly": "npm run build",
+    "build": "tsc && npm run format",
+    "prepublishOnly": "npm run test && npm run build",
     "build:docs": "NODE_ENV=production magic build",
     "prod": "NODE_ENV=production magic build serve",
     "clean": "magic clean",
@@ -61,6 +61,6 @@
     }
   ],
   "dependencies": {
-    "@types/node": "24.6.2"
+    "@types/node": "24.7.1"
   }
 }

package/src/deep/equal.js

@@ -16,9 +16,11 @@ import is from '../lib.js'
 /**
  * @param {unknown} a
  * @param {unknown} [b]
+ * @param {object} [options]
+ * @param {boolean} [options.strict=false]
  * @returns {boolean | ((c: unknown) => boolean)}
  */
-export const equal = (a, b) => {
+export const equal = (a, b, options = { strict: false }) => {
   // curry
   if (is.undefined(b)) {
     if (is.undefined(a)) {
@@ -46,7 +48,6 @@ export const equal = (a, b) => {
   //  return is.length.eq(a, b)
   // }
 
-  // Check if both are objects before accessing prototype
   if (!is.object(a) || !is.object(b)) {
     return a === b
   }
@@ -100,6 +101,11 @@ export const equal = (a, b) => {
         return false
       }
 
+      if (!options.strict) {
+        a.sort()
+        b.sort()
+      }
+
       return !a.some((v, i) => v !== b[i])
     }
 
@@ -118,8 +124,10 @@ export const equal = (a, b) => {
       return false
     }
 
-    ka.sort()
-    kb.sort()
+    if (!options.strict) {
+      ka.sort()
+      kb.sort()
+    }
 
     // ~~~cheap key test
     for (let i = 0; i < ka.length; i++) {

package/src/lib.js

@@ -1,11 +1,68 @@
 import * as fns from './fns.js'
 import * as deep from './deep/index.js'
 
-export const is = {
-  count: fns.getLength,
-  length: fns.getLength,
-  len: fns.getLength,
-  ln: fns.getLength,
+// count, length, len and ln are functions that return the length,
+// but they also have comparison methods attached as properties.
+// This creates enhanced length functions with comparison capabilities.
+
+/**
+ * @typedef {typeof fns.isLengthEqual} LengthComparison
+ */
+
+/**
+ * @typedef {typeof fns.getLength & {
+ *   eq: LengthComparison,
+ *   equal: LengthComparison,
+ *   gt: LengthComparison,
+ *   bigger: LengthComparison,
+ *   biggerequal: LengthComparison,
+ *   greater: LengthComparison,
+ *   greaterequal: LengthComparison,
+ *   gte: LengthComparison,
+ *   gteq: LengthComparison,
+ *   lower: LengthComparison,
+ *   smaller: LengthComparison,
+ *   lt: LengthComparison,
+ *   lowerequal: LengthComparison,
+ *   smallerequal: LengthComparison,
+ *   lte: LengthComparison,
+ *   lteq: LengthComparison
+ * }} EnhancedLengthFunction
+ */
+
+// Create enhanced length functions with comparison methods
+const lengthFunctions = {
+  eq: fns.isLengthEqual,
+  equal: fns.isLengthEqual,
+  gt: fns.isLengthGreater,
+  bigger: fns.isLengthGreater,
+  biggerequal: fns.isLengthGreaterOrEqual,
+  greater: fns.isLengthGreater,
+  greaterequal: fns.isLengthGreaterOrEqual,
+  gte: fns.isLengthGreaterOrEqual,
+  gteq: fns.isLengthGreaterOrEqual,
+  lower: fns.isLengthSmaller,
+  smaller: fns.isLengthSmaller,
+  lt: fns.isLengthSmaller,
+  lowerequal: fns.isLengthSmallerOrEqual,
+  smallerequal: fns.isLengthSmallerOrEqual,
+  lte: fns.isLengthSmallerOrEqual,
+  lteq: fns.isLengthSmallerOrEqual,
+}
+
+// Replace the original length functions with enhanced versions
+const ln = /** @type {EnhancedLengthFunction} */ (fns.getLength)
+Object.assign(ln, lengthFunctions)
+
+const length = ln
+const len = ln
+const count = ln
+
+export const is = /** @type {const} */ {
+  count,
+  length,
+  len,
+  ln,
 
   isError: fns.isError,
   error: fns.isError,
@@ -269,34 +326,4 @@ export const is = {
   ...deep,
 }
 
-// count, length, len and ln are functions that return the length,
-// but they also have comparison methods attached as properties.
-// This creates enhanced length functions with comparison capabilities.
-
-// Create enhanced length functions with comparison methods
-const lengthFunctions = {
-  eq: fns.isLengthEqual,
-  equal: fns.isLengthEqual,
-  gt: fns.isLengthGreater,
-  bigger: fns.isLengthGreater,
-  biggerequal: fns.isLengthGreaterOrEqual,
-  greater: fns.isLengthGreater,
-  greaterequal: fns.isLengthGreaterOrEqual,
-  gte: fns.isLengthGreaterOrEqual,
-  gteq: fns.isLengthGreaterOrEqual,
-  lower: fns.isLengthSmaller,
-  smaller: fns.isLengthSmaller,
-  lt: fns.isLengthSmaller,
-  lowerequal: fns.isLengthSmallerOrEqual,
-  smallerequal: fns.isLengthSmallerOrEqual,
-  lte: fns.isLengthSmallerOrEqual,
-  lteq: fns.isLengthSmallerOrEqual,
-}
-
-// Replace the original length functions with enhanced versions
-is.ln = fns.getLength
-Object.assign(is.ln, lengthFunctions)
-
-is.length = is.len = is.count = is.ln
-
 export default is

package/types/index.d.ts

@@ -183,10 +183,10 @@ export const is: {
       (a: unknown): (c: unknown) => boolean
     }
   }
-  count: (arg: unknown) => number
-  length: (arg: unknown) => number
-  len: (arg: unknown) => number
-  ln: (arg: unknown) => number
+  count: import('./lib.js').EnhancedLengthFunction
+  length: import('./lib.js').EnhancedLengthFunction
+  len: import('./lib.js').EnhancedLengthFunction
+  ln: import('./lib.js').EnhancedLengthFunction
   isError: (e: unknown) => e is Error
   error: (e: unknown) => e is Error
   err: (e: unknown) => e is Error

package/types/lib.d.ts

@@ -181,10 +181,10 @@ export const is: {
       (a: unknown): (c: unknown) => boolean
     }
   }
-  count: (arg: unknown) => number
-  length: (arg: unknown) => number
-  len: (arg: unknown) => number
-  ln: (arg: unknown) => number
+  count: EnhancedLengthFunction
+  length: EnhancedLengthFunction
+  len: EnhancedLengthFunction
+  ln: EnhancedLengthFunction
   isError: (e: unknown) => e is Error
   error: (e: unknown) => e is Error
   err: (e: unknown) => e is Error
@@ -508,3 +508,23 @@ export const is: {
   }
 }
 export default is
+export type LengthComparison = typeof fns.isLengthEqual
+export type EnhancedLengthFunction = typeof fns.getLength & {
+  eq: LengthComparison
+  equal: LengthComparison
+  gt: LengthComparison
+  bigger: LengthComparison
+  biggerequal: LengthComparison
+  greater: LengthComparison
+  greaterequal: LengthComparison
+  gte: LengthComparison
+  gteq: LengthComparison
+  lower: LengthComparison
+  smaller: LengthComparison
+  lt: LengthComparison
+  lowerequal: LengthComparison
+  smallerequal: LengthComparison
+  lte: LengthComparison
+  lteq: LengthComparison
+}
+import * as fns from './fns.js'