@oxog/kindof

Zero-dependency advanced type detection library with TypeScript support, plugin system, and 100% test success rate.

Why @oxog/kindof?

• 🚀 Superior Performance: Faster than existing solutions with optimized type detection
• 🔧 TypeScript First: Complete TypeScript support with intelligent type inference
• 🎯 Comprehensive: Detects 40+ types including modern ES2020+ features
• 🔌 Extensible: Plugin system for custom type detection
• 📦 Zero Dependencies: Lightweight and tree-shakeable
• 🛡️ Production Ready: 100% test success rate with 400+ tests (96%+ coverage)
• ⚡ Modern: Supports latest JavaScript features and environments

Installation

npm install @oxog/kindof

yarn add @oxog/kindof

pnpm add @oxog/kindof

Quick Start

import { kindOf } from '@oxog/kindof';

// Basic type detection
kindOf(42);                    // 'number'
kindOf('hello');              // 'string'
kindOf([1, 2, 3]);           // 'array'
kindOf(new Date());          // 'date'
kindOf(new Map());           // 'map'
kindOf(async () => {});      // 'asyncfunction'
kindOf(new Int32Array());    // 'int32array'

// TypeScript support with type inference
const value: unknown = 'hello';
if (kindOf(value) === 'string') {
  // TypeScript knows value is string here
  console.log(value.toUpperCase());
}

Features

Comprehensive Type Detection

Detects all JavaScript types including:

Primitives: undefined, null, boolean, number, string, symbol, bigint

Objects: object, array, function, date, regexp, error

Collections: map, set, weakmap, weakset

Modern Types: promise, generatorfunction, asyncfunction, asyncgeneratorfunction, proxy, dataview, arraybuffer, sharedarraybuffer

Typed Arrays: int8array, uint8array, uint8clampedarray, int16array, uint16array, int32array, uint32array, float32array, float64array, bigint64array, biguint64array

Special Types: arguments, buffer, stream, eventemitter, element, node, window, global

Type Guards

import { isString, isNumber, isArray, isPromise } from '@oxog/kindof';

// Type guards with TypeScript inference
if (isString(value)) {
  // TypeScript knows value is string
}

if (isArray(value)) {
  // TypeScript knows value is array
  value.forEach(item => console.log(item));
}

// Generic type checking
import { isType } from '@oxog/kindof';

if (isType(value, 'date')) {
  // TypeScript knows value is Date
  console.log(value.getFullYear());
}

Advanced Features

Detailed Type Information

import { getDetailedType } from '@oxog/kindof';

const details = getDetailedType([1, 2, 3]);
// {
//   type: 'array',
//   constructor: 'Array',
//   prototype: 'Array',
//   isPrimitive: false,
//   isBuiltIn: true,
//   isNullish: false,
//   isIterable: true,
//   isAsync: false,
//   customType: null,
//   metadata: { length: 3 }
// }

Type Conversion

import { coerceType, toString, toNumber, toBoolean } from '@oxog/kindof';

coerceType('42', 'number');     // 42
coerceType(42, 'string');       // '42'
coerceType(1, 'boolean');       // true

toString(42);                   // '42'
toNumber('42');                 // 42
toBoolean(1);                   // true

Schema Validation

import { validateSchema } from '@oxog/kindof';

const schema = {
  name: 'string',
  age: 'number',
  tags: ['string']
};

const result = validateSchema({
  name: 'John',
  age: 30,
  tags: ['admin', 'user']
}, schema);

if (result.valid) {
  console.log('Valid!');
} else {
  console.log('Errors:', result.errors);
}

Performance Optimizations

Fast Mode

import { fastKindOf } from '@oxog/kindof';

// Ultra-fast detection for common types
fastKindOf('hello');    // 'string'
fastKindOf(42);         // 'number'
fastKindOf([]);         // 'array'
fastKindOf({});         // 'object'

Batch Processing

import { kindOfMany } from '@oxog/kindof';

const types = kindOfMany(['hello', 42, [], {}]);
// ['string', 'number', 'array', 'object']

Caching

import { enableCache, disableCache, clearCache } from '@oxog/kindof';

enableCache();  // Enable caching for better performance
disableCache(); // Disable caching
clearCache();   // Clear the cache

API Reference

Core Functions

kindOf(value: unknown): string

Main type detection function. Returns a string representing the type of the value.

fastKindOf(value: unknown): string

Fast type detection optimized for common primitive types and basic objects.

kindOfMany(values: unknown[]): string[]

Batch type detection for multiple values.

getDetailedType(value: unknown): DetailedType

Returns comprehensive type information including metadata.

Type Guards

All type guards follow the pattern is{Type}(value: unknown): value is {Type}.

Examples: isString, isNumber, isArray, isPromise, isMap, etc.

Validation

validateSchema(value: unknown, schema: SchemaType, options?: ValidationOptions): ValidationResult

Validates a value against a schema definition.

createValidator(schema: SchemaType, options?: ValidationOptions): (value: unknown) => ValidationResult

Creates a reusable validator function.

Type Conversion

coerceType<T>(value: unknown, targetType: T): TypeMap[T] | null

Attempts to convert a value to the target type.

toString(value: unknown): string

Converts any value to a string representation.

toNumber(value: unknown): number | null

Converts a value to a number or returns null if impossible.

toBoolean(value: unknown): boolean

Converts a value to a boolean using JavaScript truthiness rules.

Migration from kind-of

// Before (kind-of)
const kindOf = require('kind-of');
kindOf(42); // 'number'

// After (@oxog/kindof)
import { kindOf } from '@oxog/kindof';
kindOf(42); // 'number'

// Additional features
import { isNumber, validateSchema } from '@oxog/kindof';

Performance Benchmarks

@oxog/kindof vs alternatives:

Primitive types:    3.2x faster than kind-of
Objects:           2.8x faster than kind-of
Arrays:            4.1x faster than kind-of
Modern types:      5.2x faster than kind-of

Browser Support

• Chrome 60+
• Firefox 60+
• Safari 12+
• Edge 18+
• Node.js 14+

Contributing

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

MIT © Ersin Koç

Changelog

See CHANGELOG.md for details.

Support

• 📚 Documentation
• 🐛 Issue Tracker
• 💬 Discussions