You're Invited:Meet the Socket Team at RSAC and BSidesSF 2026, March 23–26.RSVP →
Socket
Book a DemoSign in
Socket
Book a DemoSign in

@xylabs/typeof

Package Overview
Dependencies
Maintainers
5
Versions
412
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@xylabs/typeof - npm Package Compare versions

Comparing version
5.0.80
 to
5.0.81
+3
-6
package.json
{
"name": "@xylabs/typeof",
"version": "5.0.80",
"version": "5.0.81",
"description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",

@@ -32,3 +32,2 @@ "keywords": [

"types": "./dist/neutral/index.d.ts",
"source": "./src/index.ts",
"default": "./dist/neutral/index.mjs"

@@ -39,7 +38,5 @@ },

"module": "./dist/neutral/index.mjs",
"source": "./src/index.ts",
"types": "./dist/neutral/index.d.ts",
"files": [
"dist",
"src",
"!**/*.bench.*",

@@ -50,4 +47,4 @@ "!**/*.spec.*",

"devDependencies": {
"@xylabs/ts-scripts-yarn3": "~7.3.2",
"@xylabs/tsconfig": "~7.3.2",
"@xylabs/ts-scripts-yarn3": "~7.4.11",
"@xylabs/tsconfig": "~7.4.11",
"typescript": "~5.9.3",

@@ -54,0 +51,0 @@ "vitest": "~4.0.18"

+73
-70
README.md

@@ -26,2 +26,4 @@ # @xylabs/typeof

- [Brand](#type-aliases/Brand)
- [IdentityFunction](#type-aliases/IdentityFunction)
- [FieldType](#type-aliases/FieldType)

@@ -77,3 +79,2 @@ - [ObjectTypeShape](#type-aliases/ObjectTypeShape)

- [isWeakSet](#functions/isWeakSet)
- [isArrayBuffer](#functions/isArrayBuffer)
- [isDataView](#functions/isDataView)

@@ -95,3 +96,3 @@ - [isBlob](#functions/isBlob)

```ts
function ifDefined<T>(value, func): undefined | T;
function ifDefined<T>(value, func): T | undefined;
```

@@ -117,3 +118,3 @@

`undefined` \| `T`
`T` \| `undefined`

@@ -131,3 +132,3 @@ ### <a id="ifTypeOf"></a>ifTypeOf

trueFunc,
isFunc?): undefined | R;
isFunc?): R | undefined;
```

@@ -165,3 +166,3 @@

`undefined` \| `R`
`R` \| `undefined`

@@ -177,3 +178,3 @@ ### <a id="isArray"></a>isArray

```ts
function isArray(value): value is [];
function isArray(value): value is readonly unknown[];
```

@@ -189,3 +190,3 @@

`value is []`
`value is readonly unknown[]`

@@ -195,3 +196,3 @@ ## Call Signature

```ts
function isArray<T>(value): value is Extract<T, unknown[]>;
function isArray<T>(value): value is Extract<T, readonly unknown[]>;
```

@@ -203,26 +204,4 @@

`T` *extends* \[\]
### Parameters
### value
`T`
### Returns
`value is Extract<T, unknown[]>`
### <a id="isArrayBuffer"></a>isArrayBuffer
[**@xylabs/typeof**](#../README)
***
## Call Signature
```ts
function isArrayBuffer(value): value is ArrayBuffer;
```
### Parameters

@@ -232,24 +211,2 @@

`unknown`
### Returns
`value is ArrayBuffer`
## Call Signature
```ts
function isArrayBuffer<T>(value): value is Extract<T, ArrayBuffer>;
```
### Type Parameters
### T
`T` *extends* `ArrayBuffer`
### Parameters
### value
`T`

@@ -259,3 +216,3 @@

`value is Extract<T, ArrayBuffer>`
`value is Extract<T, readonly unknown[]>`

@@ -603,3 +560,3 @@ ### <a id="isArrayBufferView"></a>isArrayBufferView

```ts
function isDefinedNotNull<T>(value): value is Exclude<T, undefined | null>;
function isDefinedNotNull<T>(value): value is Exclude<T, null | undefined>;
```

@@ -621,3 +578,3 @@

value is Exclude\<T, undefined \| null\>
value is Exclude\<T, null \| undefined\>

@@ -897,3 +854,3 @@ ### <a id="isEmpty"></a>isEmpty

```ts
function isFalsy<T>(value): value is Extract<T, undefined | null | false | "" | 0 | 0n>;
function isFalsy<T>(value): value is Extract<T, false | "" | 0 | 0n | null | undefined>;
```

@@ -915,3 +872,3 @@

value is Extract\<T, undefined \| null \| false \| "" \| 0 \| 0n\>
value is Extract\<T, false \| "" \| 0 \| 0n \| null \| undefined\>

@@ -1331,3 +1288,3 @@ ## Call Signature

```ts
function isPopulatedArray(value): value is [];
function isPopulatedArray(value): value is readonly unknown[];
```

@@ -1343,3 +1300,3 @@

`value is []`
`value is readonly unknown[]`

@@ -1349,3 +1306,3 @@ ## Call Signature

```ts
function isPopulatedArray<T>(value): value is Extract<T, unknown[]>;
function isPopulatedArray<T>(value): value is Extract<T, readonly unknown[]>;
```

@@ -1367,3 +1324,3 @@

`value is Extract<T, unknown[]>`
`value is Extract<T, readonly unknown[]>`

@@ -1643,3 +1600,3 @@ ### <a id="isPromise"></a>isPromise

```ts
function isTruthy<T>(value): value is Exclude<T, undefined | null | false | "" | 0 | 0n>;
function isTruthy<T>(value): value is Exclude<T, false | "" | 0 | 0n | null | undefined>;
```

@@ -1661,3 +1618,3 @@

value is Exclude\<T, undefined \| null \| false \| "" \| 0 \| 0n\>
value is Exclude\<T, false \| "" \| 0 \| 0n \| null \| undefined\>

@@ -1953,3 +1910,3 @@ ## Call Signature

```ts
function isUndefinedOrNull(value): value is undefined | null;
function isUndefinedOrNull(value): value is null | undefined;
```

@@ -1965,3 +1922,3 @@

value is undefined \| null
value is null \| undefined

@@ -1971,3 +1928,3 @@ ## Call Signature

```ts
function isUndefinedOrNull<T>(value): value is Extract<T, undefined | null>;
function isUndefinedOrNull<T>(value): value is Extract<T, null | undefined>;
```

@@ -1989,3 +1946,3 @@

value is Extract\<T, undefined \| null\>
value is Extract\<T, null \| undefined\>

@@ -2148,3 +2105,3 @@ ### <a id="isValidTypedFieldPair"></a>isValidTypedFieldPair

value,
optional): [undefined | T, Error[]];
optional?): [T | undefined, Error[]];
```

@@ -2168,3 +2125,3 @@

### optional
### optional?

@@ -2175,3 +2132,3 @@ `boolean` = `false`

\[`undefined` \| `T`, `Error`[]\]
\[`T` \| `undefined`, `Error`[]\]

@@ -2200,2 +2157,22 @@ ### type-aliases

### <a id="Brand"></a>Brand
[**@xylabs/typeof**](#../README)
***
```ts
type Brand<T, B> = T & { [K in keyof B]: B[K] };
```
## Type Parameters
### T
`T`
### B
`B`
### <a id="FieldType"></a>FieldType

@@ -2219,2 +2196,28 @@

### <a id="IdentityFunction"></a>IdentityFunction
[**@xylabs/typeof**](#../README)
***
```ts
type IdentityFunction<T> = (value) => value is T;
```
## Type Parameters
### T
`T`
## Parameters
### value
`unknown`
## Returns
`value is T`
### <a id="ObjectTypeShape"></a>ObjectTypeShape

@@ -2221,0 +2224,0 @@ 

-1
src/Brand.ts
export type Brand<T, B> = T & { [K in keyof B]: B[K] }
-1
src/IdentityFunction.ts
export type IdentityFunction<T> = (value: unknown) => value is T
-14
src/ifDefined.ts
import { typeOf } from './typeOf.ts'
export const ifDefined = <T>(value: T, func: (value: T) => void) => {
switch (typeOf(value)) {
case 'undefined':
case 'null': {
break
}
default: {
func(value)
return value
}
}
}
-10
src/ifTypeOf.ts
import { typeOf } from './typeOf.ts'
import type { TypeOfTypes } from './TypeOfTypes.ts'
export const ifTypeOf = <T, R>(typeName: TypeOfTypes, value: unknown, trueFunc: (value: T) => R, isFunc?: (value: T) => boolean) => {
switch (typeOf(value)) {
case typeName: {
return !isFunc || isFunc(value as T) ? trueFunc(value as T) : undefined
}
}
}
-11
src/index.ts
export * from './Brand.ts'
export * from './IdentityFunction.ts'
export * from './ifDefined.ts'
export * from './ifTypeOf.ts'
export * from './is.ts'
export * from './isType.ts'
export * from './ObjectTypeShape.ts'
export * from './Typed.ts'
export * from './typeOf.ts'
export * from './TypeOfTypes.ts'
export * from './validateType.ts'
-217
src/is.ts
export type AnyFunction = (...args: unknown[]) => unknown
export type RecordKey = string | number | symbol
export function isUndefined(value: unknown): value is undefined
export function isUndefined<T>(value: T): value is Extract<T, undefined>
export function isUndefined(value: unknown): value is undefined {
return value === undefined
}
export function isDefined<T>(value: T): value is Exclude<T, undefined> {
return !isUndefined(value)
}
export function isNull(value: unknown): value is null
export function isNull<T>(value: T): value is Extract<T, null>
export function isNull(value: unknown): value is null {
return value === null
}
export function isDefinedNotNull<T>(value: T): value is Exclude<T, undefined | null> {
return !isUndefined(value) && !isNull(value)
}
export function isUndefinedOrNull(value: unknown): value is undefined | null
export function isUndefinedOrNull<T>(value: T): value is Extract<T, undefined | null>
export function isUndefinedOrNull(value: unknown): value is undefined | null {
return isUndefined(value) || isNull(value)
}
export function isBigInt(value: unknown): value is bigint
export function isBigInt<T extends bigint>(value: T): value is Extract<T, bigint>
export function isBigInt(value: unknown): value is bigint {
return typeof value === 'bigint'
}
export function isString(value: unknown): value is string
export function isString<T extends string>(value: T): value is Extract<T, string>
export function isString(value: unknown): value is string {
return typeof value === 'string'
}
export function isNumber(value: unknown): value is number
export function isNumber<T extends number>(value: T): value is Extract<T, number>
export function isNumber(value: unknown): value is number {
return typeof value === 'number'
}
export function isObject(value: unknown): value is object
export function isObject<T extends object>(value: T): value is Extract<T, object>
export function isObject(value: unknown): value is object {
return (typeof value === 'object') && (value !== null) && !Array.isArray(value)
}
export function isArray(value: unknown): value is readonly unknown[]
export function isArray<T>(value: T): value is Extract<T, readonly unknown[]>
export function isArray(value: unknown): value is readonly unknown[] {
return Array.isArray(value)
}
export function isFunction(value: unknown): value is AnyFunction
export function isFunction<T extends AnyFunction>(value: T): value is Extract<T, AnyFunction>
export function isFunction(value: unknown): value is AnyFunction {
return typeof value === 'function'
}
export function isSymbol(value: unknown): value is symbol
export function isSymbol<T extends symbol>(value: T): value is Extract<T, symbol>
export function isSymbol(value: unknown): value is symbol {
return typeof value === 'symbol'
}
export function isEmptyObject(value: unknown): value is {}
export function isEmptyObject<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>
export function isEmptyObject(value: unknown): value is {} {
return isObject(value) && Object.keys(value).length === 0
}
export function isEmptyString(value: unknown): value is ''
export function isEmptyString<T extends string>(value: T): value is Extract<T, ''>
export function isEmptyString(value: unknown): value is '' {
return isString(value) && value.length === 0
}
export function isEmptyArray(value: unknown): value is []
export function isEmptyArray<T extends Array<unknown>>(value: T): value is Extract<T, Array<unknown>>
export function isEmptyArray(value: unknown): value is [] {
return isArray(value) && value.length === 0
}
export function isPopulatedArray(value: unknown): value is readonly unknown[]
export function isPopulatedArray<T extends Array<unknown>>(value: T): value is Extract<T, readonly unknown[]>
export function isPopulatedArray(value: unknown): value is readonly unknown[] {
return isArray(value) && value.length > 0
}
export function isEmpty<T>(value: unknown): value is T
export function isEmpty<K extends RecordKey, V, T extends Record<K, V>>(value: T): value is Extract<T, Record<K, never>>
export function isEmpty<T extends Array<unknown>>(value: T): value is Extract<T, Array<never>>
export function isEmpty<T>(value: unknown): value is T {
return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value)
}
export function isFalsy<T>(value: T): value is Extract<T, 0 | null | undefined | false | '' | 0n>
export function isFalsy<T extends boolean>(value: T): value is Extract<T, false>
export function isFalsy<T extends number>(value: T): value is Extract<T, 0>
export function isFalsy<T extends bigint>(value: T): value is Extract<T, 0n>
export function isFalsy<T extends null>(value: T): value is Extract<T, null>
export function isFalsy<T extends undefined>(value: T): value is Extract<T, undefined>
export function isFalsy<T extends string>(value: T): value is Extract<T, ''>
export function isFalsy<T>(value: T): value is T {
return !value
}
export function isTruthy<T>(value: T): value is Exclude<T, 0 | null | undefined | false | '' | 0n>
export function isTruthy<T extends boolean>(value: T): value is Extract<T, true>
export function isTruthy<T extends number>(value: T): value is Extract<T, number>
export function isTruthy<T extends bigint>(value: T): value is Extract<T, bigint>
export function isTruthy<T extends null>(value: T): value is Extract<T, null>
export function isTruthy<T extends undefined>(value: T): value is Extract<T, undefined>
export function isTruthy<T extends string>(value: T): value is Extract<T, string>
export function isTruthy<T>(value: T): value is T {
return !!value
}
export function isBoolean(value: unknown): value is boolean
export function isBoolean<T extends boolean>(value: T): value is Extract<T, boolean>
export function isBoolean(value: unknown): value is boolean {
return typeof value === 'boolean'
}
export function isDateString(value: unknown): value is string
export function isDateString<T>(value: T): value is Extract<T, string>
export function isDateString(value: unknown): value is string {
return isString(value) && !Number.isNaN(Date.parse(value))
}
export function isDate(value: unknown): value is Date
export function isDate<T>(value: T): value is Extract<T, Date>
export function isDate(value: unknown): value is Date {
return value instanceof Date
}
export function isRegExp(value: unknown): value is RegExp
export function isRegExp<T extends RegExp>(value: T): value is Extract<T, RegExp>
export function isRegExp(value: unknown): value is RegExp {
return value instanceof RegExp
}
export function isError(value: unknown): value is Error
export function isError<T>(value: T): value is Extract<T, Error>
export function isError(value: unknown): value is Error {
return value instanceof Error
}
export function isPromise(value: unknown): value is Promise<unknown>
export function isPromise<T>(value: T): value is Extract<T, Promise<unknown>>
export function isPromise(value: unknown): value is Promise<unknown> {
return value instanceof Promise
}
export function isPromiseLike(value: unknown): value is Promise<unknown>
export function isPromiseLike<T>(value: T): value is Extract<T, Promise<unknown>>
export function isPromiseLike(value: unknown): value is Promise<unknown> {
return (
typeof value === 'object'
&& value !== null
&& typeof (value as Record<string, unknown>).then === 'function'
)
}
export function isMap(value: unknown): value is Map<unknown, unknown>
export function isMap<K, V, T extends Map<K, V>>(value: T): value is Extract<T, Map<K, V>>
export function isMap(value: unknown): value is Map<unknown, unknown> {
return value instanceof Map
}
export function isArrayBufferView(value: unknown): value is ArrayBufferView
export function isArrayBufferView<T extends ArrayBufferView>(value: T): value is Extract<T, ArrayBufferView>
export function isArrayBufferView(value: unknown): value is ArrayBufferView {
return ArrayBuffer.isView(value)
}
export function isSet(value: unknown): value is Set<unknown>
export function isSet<T extends Set<unknown>>(value: unknown | Set<T>): value is Extract<T, Set<unknown>>
export function isSet(value: unknown): value is Set<unknown> {
return value instanceof Set
}
export function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown>
export function isWeakMap<K extends WeakKey, V, T extends WeakMap<K, V>>(value: T): value is Extract<T, WeakMap<K, V>>
export function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown> {
return value instanceof WeakMap
}
export function isWeakSet(value: unknown): value is WeakSet<WeakKey>
export function isWeakSet<K extends WeakKey, T extends WeakSet<K>>(value: T): value is Extract<T, WeakSet<K>>
export function isWeakSet(value: unknown): value is WeakSet<WeakKey> {
return value instanceof WeakSet
}
export function isDataView(value: unknown): value is DataView
export function isDataView<T>(value: T): value is Extract<T, DataView>
export function isDataView(value: unknown): value is DataView {
return value instanceof DataView
}
export function isBlob(value: unknown): value is Blob
export function isBlob<T extends Blob>(value: T): value is Extract<T, Blob>
export function isBlob(value: unknown): value is Blob {
return typeof Blob !== 'undefined' && value instanceof Blob
}
export function isFile(value: unknown): value is File
export function isFile<T extends File>(value: T): value is Extract<T, File>
export function isFile(value: unknown): value is File {
return typeof File !== 'undefined' && value instanceof File
}
-27
src/isType.ts
import type { FieldType } from './ObjectTypeShape.ts'
export const isType = (value: unknown, expectedType: FieldType) => {
const typeofValue = typeof value
switch (expectedType) {
case 'array': {
return Array.isArray(value)
}
case 'null': {
return value === null
}
case 'undefined': {
return value === undefined
}
case 'object': {
// nulls resolve to objects, so exclude them
if (value === null) {
return false
}
// arrays resolve to objects, so exclude them
return typeofValue === 'object' && !Array.isArray(value)
}
default: {
return typeofValue === expectedType
}
}
}
-3
src/ObjectTypeShape.ts
export type FieldType = 'string' | 'number' | 'object' | 'symbol' | 'undefined' | 'null' | 'array' | 'function'
export type ObjectTypeShape = Record<string | number | symbol, FieldType>
-66
src/Typed.ts
import { isType } from './isType.ts'
// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
export type TypedValue = bigint | string | number | boolean | null | TypedObject | TypedArray | Function | symbol | undefined
export type TypedKey<T extends string | void = void> = T extends string ? T : string | number | symbol
export type TypedObject = { [key: TypedKey]: TypedValue } | object
export type TypedArray = TypedValue[]
export const isTypedKey = (value: unknown): value is TypedKey => {
switch (typeof value) {
case 'string':
case 'bigint':
case 'number':
case 'symbol': {
return true
}
default: {
return false
}
}
}
export const isTypedValue = (value: unknown): value is TypedValue => {
switch (typeof value) {
case 'string':
case 'number':
case 'boolean': {
return true
}
default: {
return value === null || isTypedObject(value) || isTypedArray(value)
}
}
}
export const isTypedArray = (value: unknown): value is TypedArray => {
return Array.isArray(value) && !value.some(item => !isTypedValue(item))
}
export const isValidTypedFieldPair = (pair: [key: unknown, value: unknown]): pair is [key: TypedKey, value: TypedValue] => {
const [key, value] = pair
return isTypedKey(key) && isTypedValue(value)
}
export const isTypedObject = (value: unknown): value is TypedObject => {
return (
isType(value, 'object')
// check if all keys are strings
&& !Object.entries(value as object).some(item => !isValidTypedFieldPair(item))
)
}
// Object Type Test
/*
interface TestObject {
value: number
}
const x: TestObject = { value: 1 }
const f = (p: TypedValue): void => {
console.log(p)
}
f(x)
*/
-5
src/typeOf.ts
import type { TypeOfTypes } from './TypeOfTypes.ts'
export const typeOf = <T>(item: T): TypeOfTypes => {
return Array.isArray(item) ? 'array' : typeof item
}
-1
src/TypeOfTypes.ts
export type TypeOfTypes = 'string' | 'number' | 'object' | 'array' | 'buffer' | 'null' | 'undefined' | 'bigint' | 'boolean' | 'function' | 'symbol'
-16
src/validateType.ts
import { typeOf } from './typeOf.ts'
import type { TypeOfTypes } from './TypeOfTypes.ts'
export const validateType = <T>(typeName: TypeOfTypes, value: T, optional = false): [T | undefined, Error[]] => {
switch (typeOf(value)) {
case typeName: {
return [value, []]
}
default: {
if (optional && typeOf(value) === 'undefined') {
return [value, []]
}
return [undefined, [new Error(`value type is not '${typeName}:${typeof value}'`)]]
}
}
}