@magic/types 0.1.32 → 0.1.34

package/README.md

@@ -380,6 +380,16 @@ update dependencies
 
 - add is.symbol, is.sym and isSymbol functions
 
-##### 0.1.33 - unreleased
+##### 0.1.33
+
+- is.instance now typeguards
+- update dependencies
+
+##### 0.1.34
+
+- add gt, gte, lt, lte and all other numerical value comparators into root, is.gt, is.lt etc.
+- update dependencies
+
+##### 0.1.35 - unreleased
 
 ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/types",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "author": "Wizards & Witches",
   "homepage": "https://github.com/magic/types",
   "license": "AGPL-3.0",
@@ -45,9 +45,9 @@
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
     "@magic/core": "0.0.156",
-    "@magic/format": "0.0.72",
-    "@magic/test": "0.2.29",
-    "typescript": "5.9.3"
+    "@magic/format": "0.0.73",
+    "@magic/test": "0.2.30",
+    "typescript": "6.0.3"
   },
   "keywords": [
     "magic",
@@ -61,6 +61,6 @@
     }
   ],
   "dependencies": {
-    "@types/node": "25.5.0"
+    "@types/node": "25.6.0"
   }
 }

package/src/fns.js

@@ -209,16 +209,16 @@ export const isFalsy = e => !e || isEmpty(e)
  * @returns {number} - length/size or -1 if unknown
  */
 export const getLength = arg => {
-  if (Array.isArray(arg) || typeof arg === 'string' || isBuffer(arg)) {
+  if (isArray(arg) || isString(arg) || isBuffer(arg)) {
     return arg.length
   }
-  if (isInteger(arg)) {
+  if (isNumber(arg)) {
     return arg
   }
-  if (arg instanceof Map || arg instanceof Set) {
+  if (isInstanceOf(arg, Map) || isInstanceOf(arg, Set)) {
     return arg.size
   }
-  if (arg instanceof RegExp) {
+  if (isInstanceOf(arg, RegExp)) {
     const str = arg.toString()
     return str === '/(?:)/' ? 0 : str.length - 2 // length of pattern without slashes
   }
@@ -520,9 +520,10 @@ export const isNone = (arr, t) => !isSome(arr, t)
 
 /**
  * Check if a value is an instance of a given constructor
+ * @template T
  * @param {unknown} e - value to check
- * @param {new (...args: any[]) => any} t - constructor function
- * @returns {boolean} - true if value is an instance of constructor
+ * @param {new (...args: any[]) => T} t - constructor function
+ * @returns {e is T} - true if value is an instance of constructor
  */
 export const isInstanceOf = (e, t) => (!t ? false : e instanceof t)
 

package/src/lib.js

@@ -59,6 +59,8 @@ const len = ln
 const count = ln
 
 export const is = /** @type {const} */ {
+  ...lengthFunctions,
+
   count,
   length,
   len,

package/types/fns.d.ts

@@ -140,7 +140,7 @@ export function isComparable(a: unknown): a is string | number | boolean
 export function isEvery<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
 export function isSome<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
 export function isNone<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
-export function isInstanceOf(e: unknown, t: new (...args: any[]) => any): boolean
+export function isInstanceOf<T>(e: unknown, t: new (...args: any[]) => T): e is T
 export function isError(e: unknown): e is Error
 export function isDate(e: unknown): e is Date
 export function isRegExp(e: unknown): e is RegExp

package/types/index.d.ts

@@ -480,9 +480,9 @@ export const is: {
   all: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
   some: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
   none: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
-  instance: (e: unknown, t: new (...args: any[]) => any) => boolean
-  instanceof: (e: unknown, t: new (...args: any[]) => any) => boolean
-  instanceOf: (e: unknown, t: new (...args: any[]) => any) => boolean
+  instance: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
+  instanceof: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
+  instanceOf: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
   isCase: ((s: unknown, c?: 'up' | 'down') => boolean) & {
     upper: (s: unknown) => boolean
     lower: (s: unknown) => boolean
@@ -510,5 +510,245 @@ export const is: {
   module: (s: unknown) => s is object & {
     [Symbol.toStringTag]: 'Module'
   }
+  eq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  equal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gt: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  bigger: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  biggerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  greater: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  greaterequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gte: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gteq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lower: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  smaller: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lt: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lowerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  smallerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lte: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lteq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
 }
 export default is

package/types/lib.d.ts

@@ -478,9 +478,9 @@ export const is: {
   all: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
   some: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
   none: <T>(arr: T | T[], t: ((v: T) => boolean) | string) => boolean
-  instance: (e: unknown, t: new (...args: any[]) => any) => boolean
-  instanceof: (e: unknown, t: new (...args: any[]) => any) => boolean
-  instanceOf: (e: unknown, t: new (...args: any[]) => any) => boolean
+  instance: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
+  instanceof: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
+  instanceOf: <T>(e: unknown, t: new (...args: any[]) => T) => e is T
   isCase: ((s: unknown, c?: 'up' | 'down') => boolean) & {
     upper: (s: unknown) => boolean
     lower: (s: unknown) => boolean
@@ -508,6 +508,246 @@ export const is: {
   module: (s: unknown) => s is object & {
     [Symbol.toStringTag]: 'Module'
   }
+  eq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  equal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gt: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  bigger: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  biggerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  greater: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  greaterequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gte: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  gteq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lower: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  smaller: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lt: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lowerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  smallerequal: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lte: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
+  lteq: {
+    /**
+     * @overload
+     * @param {unknown} a
+     * @param {unknown} b
+     * @returns {boolean}
+     */
+    (a: unknown, b: unknown): boolean
+    /**
+     * @overload
+     * @param {unknown} a
+     * @returns {(c: unknown) => boolean}
+     */
+    (a: unknown): (c: unknown) => boolean
+  }
 }
 export default is
 export type LengthComparison = typeof fns.isLengthEqual