is-type-of

import is from "is-type-of";
import { isArray, isString, isNumber } from "is-type-of";

const is = require("is-type-of");
const { isArray, isString } = require("is-type-of");

import is from "is-type-of";
import { isArray, isString } from "is-type-of";

// Using the main is object
is.array([1, 2, 3]); // => true
is.string("hello"); // => true
is.primitive(42); // => true
is.primitive({}); // => false

// Using named imports
isArray([1, 2, 3]); // => true
isString("hello"); // => true

// Type guard usage in TypeScript
function processValue(value: string | number[]) {
  if (isArray(value)) {
    // value is now typed as number[]
    value.forEach(console.log);
  } else {
    // value is now typed as string
    console.log(value.toUpperCase());
  }
}

// Core primitive checkers
function isString(val?: unknown): val is string;
function isNumber(val?: unknown): val is number;
function isBoolean(val?: unknown): val is boolean;
function isSymbol(val?: unknown): val is symbol;
function isUndefined(val?: unknown): val is undefined;
function isNull(val?: unknown): val is null;
function isBigInt(val?: unknown): val is bigint;

// Composite primitive checkers
function isNullable(val?: unknown): val is null | undefined;
function isPrimitive(val?: unknown): val is Primitive;

// Number specializations
function isInteger(val?: unknown): val is number;
function isInteger32(val?: unknown): val is number;
function isLong(val?: unknown): val is number;
function isSafeInteger(val?: unknown): val is number;
function isDouble(val?: unknown): val is number;
function isNaN(val?: unknown): boolean;
function isFinite(val?: unknown): val is number;

// Core object checkers
function isArray<T = any>(val?: unknown): val is Array<T>;
function isFunction<T extends Function>(val?: unknown): val is T;
function isObject(val?: unknown): val is object;
function isDate(val?: unknown): val is Date;
function isError(val?: unknown): val is Error;
function isRegExp(val?: unknown): val is RegExp;

// Function specializations
function isGeneratorFunction(val?: unknown): val is GeneratorFunction;
function isAsyncFunction(val?: unknown): val is Function;
function isAsyncGeneratorFunction(val?: unknown): val is AsyncGeneratorFunction;
function isClass<T extends Class>(val?: unknown): val is T;

// Advanced objects
function isGenerator(val?: unknown): val is Generator;
function isPromise<T = any>(val?: unknown): val is Promise<T>;
function isPromiseLike<T = any>(val?: unknown): val is PromiseLike<T>;

function isBuffer(val: unknown): val is Buffer;
function isStream(val?: unknown): val is Stream;
function isReadable(val?: unknown): val is Readable;
function isWritable(val?: unknown): val is Writable;
function isDuplex(val?: unknown): val is Duplex;

function isLongObject(obj?: unknown): obj is LongObject;

interface LongObject {
  high: number;
  low: number;
}

/**
 * Returns true if val is an instance of the given class constructor
 * @param val - Value to check
 * @param Clazz - Constructor function to check against
 * @returns Type guard indicating if value is instance of Clazz
 */
function isInstanceOf<T extends Class>(val: unknown, Clazz: T): val is InstanceType<T>;

import { isInstanceOf } from "is-type-of";

class MyClass {
  value: number;
  constructor(value: number) {
    this.value = value;
  }
}

const instance = new MyClass(42);
const obj = { value: 42 };

isInstanceOf(instance, MyClass); // => true
isInstanceOf(obj, MyClass);      // => false

// Type guard usage
function processValue(val: unknown) {
  if (isInstanceOf(val, MyClass)) {
    // val is now typed as MyClass
    console.log(val.value);
  }
}

const is: {
  // Primitive types
  boolean: typeof isBoolean;
  number: typeof isNumber;
  string: typeof isString;
  symbol: typeof isSymbol;
  undefined: typeof isUndefined;
  null: typeof isNull;
  nullable: typeof isNullable;
  bigInt: typeof isBigInt;
  primitive: typeof isPrimitive;
  integer: typeof isInteger;
  integer32: typeof isInteger32;
  long: typeof isLong;
  double: typeof isDouble;
  finite: typeof isFinite;
  NaN: typeof isNaN;
  safeInteger: typeof isSafeInteger;

  // Standard objects
  function: typeof isFunction;
  generatorFunction: typeof isGeneratorFunction;
  asyncFunction: typeof isAsyncFunction;
  asyncGeneratorFunction: typeof isAsyncGeneratorFunction;
  class: typeof isClass;
  array: typeof isArray;
  object: typeof isObject;
  date: typeof isDate;
  error: typeof isError;
  regExp: typeof isRegExp;
  generator: typeof isGenerator;
  promise: typeof isPromise;
  promiseLike: typeof isPromiseLike;

  // Node.js objects
  buffer: typeof isBuffer;
  stream: typeof isStream;
  readable: typeof isReadable;
  writable: typeof isWritable;
  duplex: typeof isDuplex;

  // External objects
  longObject: typeof isLongObject;
};

type Primitive = string | number | bigint | boolean | symbol | null | undefined;
type Nullable = null | undefined;
type Class = new (...args: any[]) => any;

interface LongObject {
  high: number;
  low: number;
}