@magic/types 0.1.31 → 0.1.33

package/README.md

@@ -190,6 +190,9 @@ isSome([1, 'str', {}], 'number') // true
 isSome([1, 'str', {}], is.number) // true
 // alias is.some
 
+isSymbol(Symbol('testing)) // true
+// alias is.symbol, is.sym
+
 isNone([1, 2, 3], 'string') // true
 isNone([1, 2, 3], is.number) // false
 // alias is.none
@@ -373,6 +376,15 @@ update dependencies
 
 - update dependencies
 
-##### 0.1.32 - unreleased
+##### 0.1.32
+
+- add is.symbol, is.sym and isSymbol functions
+
+##### 0.1.33
+
+- is.instance now typeguards
+- update dependencies
+
+##### 0.1.34 - unreleased
 
 ...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic/types",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "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.68",
-    "@magic/test": "0.2.25",
-    "typescript": "5.9.3"
+    "@magic/format": "0.0.72",
+    "@magic/test": "0.2.30",
+    "typescript": "6.0.2"
   },
   "keywords": [
     "magic",
@@ -61,6 +61,6 @@
     }
   ],
   "dependencies": {
-    "@types/node": "24.9.2"
+    "@types/node": "25.5.0"
   }
 }

package/src/fns.js

@@ -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)
 
@@ -554,6 +555,13 @@ export const isRegExp = e => isInstanceOf(e, RegExp)
  */
 export const isMap = a => isInstanceOf(a, Map)
 
+/**
+ * Check if a value is a Symbol
+ * @param {unknown} a - value to check
+ * @returns {a is Symbol} - true if value is a Symbol
+ */
+export const isSymbol = a => typeof a === 'symbol'
+
 /**
  * Check if a value is a Set
  * @param {unknown} a - value to check

package/src/lib.js

@@ -83,6 +83,9 @@ export const is = /** @type {const} */ {
   null: fns.isNull,
   nil: fns.isNull,
 
+  sym: fns.isSymbol,
+  symbol: fns.isSymbol,
+
   isUndefinedOrNull: fns.isUndefinedOrNull,
   undefinedOrNull: fns.isUndefinedOrNull,
   undefinedOrNil: fns.isUndefinedOrNull,

package/types/fns.d.ts

@@ -140,11 +140,12 @@ 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
 export function isMap(a: unknown): a is Map<unknown, unknown>
+export function isSymbol(a: unknown): a is Symbol
 export function isSet(a: unknown): a is Set<unknown>
 export function isWeakMap(a: unknown): a is WeakMap<any, unknown>
 export function isWeakSet(a: unknown): a is WeakSet<any>

package/types/index.d.ts

@@ -202,6 +202,8 @@ export const is: {
   isNil: (e: unknown) => e is null
   null: (e: unknown) => e is null
   nil: (e: unknown) => e is null
+  sym: (a: unknown) => a is Symbol
+  symbol: (a: unknown) => a is Symbol
   isUndefinedOrNull: (e: unknown) => e is null | undefined
   undefinedOrNull: (e: unknown) => e is null | undefined
   undefinedOrNil: (e: unknown) => e is null | undefined
@@ -478,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

package/types/lib.d.ts

@@ -200,6 +200,8 @@ export const is: {
   isNil: (e: unknown) => e is null
   null: (e: unknown) => e is null
   nil: (e: unknown) => e is null
+  sym: (a: unknown) => a is Symbol
+  symbol: (a: unknown) => a is Symbol
   isUndefinedOrNull: (e: unknown) => e is null | undefined
   undefinedOrNull: (e: unknown) => e is null | undefined
   undefinedOrNil: (e: unknown) => e is null | undefined
@@ -476,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