@p4ck493/ts-is v3.0.11

ts-is

🌍 Languages

🇺🇦 ukraine | 🇬🇧 english

Introduction

Why you should use and support the package:

1. ✅ Typification.
2. ✅ Reducing the code in the project.
3. ✅ Easier to read and understand the code.
4. ✅ CDN support.
5. ✅ Compatible with the oldest version of JavaScript (ES6 - ECMAScript 2015).
6. ✅ Compatible with the oldest version of TypeScript (0.8.0).
7. ✅ Maintenance of global contexts: globalThis, window, self, global.
8. ✅ No dependencies
9. ✅ AMD, Node & browser ready
10. ✅ Small size: ~8KB.

💡 Idea

this package was created in order to simplify writing in typescript / javascript, it often happens that you need to have checks for different types of data, these checks can be "huge", but if you could simply describe in words what we want to check?

For example, why write:

if (typeof variable === 'object' && variable !== null && !Array.isArray(variable) && Object.keys(variable)?.length) {
}

if you can write something like:

if (is.object.not.empty(variable)) {
}

📝 Table of contents

• ts-is
  • Idea
  • Introduction
  • Table of contents
  • Installation
  • CDN
  • Usage
    • Example
      • Syntax
      • Methods
      • Methods with connection
      • Methods with wrappers
      • Methods with your models
      • Custom method
    • Use Cases
      • array:filter
      • array:some
      • array:every
      • observable:pipe:filter
  • API
  • New methods that are available through the package, but which are only declared in the package, but actually take data from outside the package.
    • General (841 methods)
    • HTML (80 methods)
  • Additional
  • Contributing
  • Authors
  • License

💿 Installation

npm install @p4ck493/ts-is

🔗 CDN

<script>
  var exports = {};
</script>
<script src="//unpkg.com/@p4ck493/ts-is@3.0.8/dist/index.js"></script>
<script>
  const { is } = exports;
  console.log(is.string('')); // true
</script>

Back to table of contents

🙌 Usage

import {is} from "@p4ck493/ts-is";

Examples

Syntax

$method = 'ANY_METHOD_NAME';

is[$method]();
is[$method][$method]();
is[$method].or[$method]();
is[$method].not[$method]();

$model = 'ANY_MODEL_WICH_DECLARE_IN_PACKAGE_BY_DECORATOR'; // Decorator: @RegisterInIs()

is[$model]();
is[$model][$model]();
is[$model].or[$model]();
is[$model].not[$model]();

// And yes, you can mix:

is[$cmd][$model]();
is[$model].or[$cmd]();
is[$cmd].not[$model]();

Methods

import {IsConfig} from './index';

is.array([]); // true

is.bigInt(1n); // true

is.boolean(false); // true

is.compare({a: 1}, {a: 1}); // true
is.compare({a: 1}, {}); // false
is.compare({}, {a: 1}); // false
is.compare({}, {}); // true

is.Date(new Date()); // true

is.empty(''); // true
is.empty(' '); // true
is.empty(new Map()); // true
is.empty({}); // true
is.empty([]); // true

is.Error(new Error()); // true

is.EvalError(new EvalError()); // true

is.false(false); // true

is.DataView(new DataView(new ArrayBuffer(16), 0)); // true

is.falsy(''); // true

// This method will check if the argument is equal to the base type: Function
is.Function(() => {
}); // true

// This method checks not only if the argument is a function, but also if the argument is an asynchronous function or a generative
is.function(() => {
}); // true

is.instanceof(new Boolean(false), Boolean); // true

is.Map(new Map()); // true

is.null(null); // true

is.number(0); // true

is.object({}); // true

is.ReferenceError(new ReferenceError()); // true

is.RegExp(new RegExp()); // true

is.Set(new Set()); // true

is.string(''); // true

is.symbol(Symbol()); // true

is.SyntaxError(new SyntaxError()); // true

is.true(true); // true

is.truthy(1); // true

is.TypeError(new TypeError()); // true

is.undefined(undefined); // true

is.URIError(new URIError()); // true

is.WeakMap(new WeakMap()); // true

is.WeakSet(new WeakSet()); // true

is.len_5('words') // true
is.len_4('words') // false
is.len_gt_4('words') // true
is.len_lt_5('words') // false
is.len_lte_5('words') // true
is.len_gte_5('words') // true
is.len_gt_4_lt_6('words') // true
is.len_gte_5_lt_6('words') // true
is.len_gt_4_lte_5('words') // true

// You can also configure global package settings
IsConfig.error.enabled = false; // In this case, all console.error will be disabled, they are enabled by default.

// If you need to change the regex say for macAddress, here is an example:
IsConfig.regex.macAddress = /[Your regex]/;

// If you don't want the package to fight in the global context, then do it like this:
IsConfig.useGlobalContext = false;

Methods with connection

is.array.empty([]); // true

is.bigInt.or.number(-1); // true

is.boolean.or.truthy('false'); // true

is.false.or.falsy(''); // true

is.null.or.undefined(null); // true

is.object.or.Function({}); // true
is.object.or.function({}); // true

is.string.or.true.or.symbol(true); // true

Methods with wrappers

is.object.not.empty({ a: 1 }); // true

is.not.object({}); // false

is.not.number(1n); // true

Back to table of contents

Methods with your models

You have the option to add any class to the package yourself for further testing

@RegisterInIs({
  className: 'person', // You can customize the model name, i.e.: is.person((new Person())) // true
})
class PersonModel {}

@RegisterInIs({
  className: 'woman',
})
class WomanModel extends PersonModel {}

@RegisterInIs({
  className: 'man',
})
class ManModel extends PersonModel {}

@RegisterInIs()
class AddressModel {}

const person = new PersonModel();
const man = new ManModel();
const woman = new WomanModel();
const address = new AddressModel();

is.person(person); // true

is.person(man); // true

is.person(woman); // true

is.person(address); // false

is.man(person); // false

is.woman(person); // false

is.AddressModel(address); // true

is.woman.or.man(woman); // true

is.not.woman(man); // true

is.not.man(man); // false

// Good Example: Cart

@RegisterInIs()
class Cart {
  public size: number = 0;
}

const cart: Cart = new Cart();
is.Cart.empty(cart); // true
cart.size = 1;
is.Cart.empty(cart); // false

// Bad Example: Cart

@RegisterInIs()
class CartTwo {
  public total: number = 0;
}

const cartTwo: CartTwo = new CartTwo();
is.CartTwo.empty(cartTwo); // false
cartTwo.size = 1;
is.CartTwo.empty(cartTwo); // false

CDN

const { RegisterInIs } = exports;

// Person
class PersonModel {
  // Your code ...
}

RegisterInIs()(PersonModel);

// Woman
class WomanModel extends PersonModel {
  // Your code ...
}

RegisterInIs({
  className: 'woman',
})(WomanModel);

// Check
const person = new PersonModel();
const woman = new WomanModel();

// Check
is.PersonModel(person); // true
is.PersonModel(woman); // true
is.woman(woman); // true
is.woman(person); // false

Custom method

@RegisterInIs({
  customMethod: 'customNameOfMethod',
})
class PostModel {
  public static customNameOfMethod(argument: unknown): argument is PostModel {
    return `Hello ${argument}`;
  }
}

is.PostModel('world'); // Returns: Hello world

Back to table of contents

Use Cases

array:filter

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.filter(is.number)); // [0, 1]

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.filter(is.string)); // ['', 'test']

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.filter(is.string.not.empty)); // ['test']

array:some

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.some(is.string.or.object)); // true

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.some(is.not.symbol)); // false

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.some(is.string.empty)); // true

array:every

const onlyNumbers: number[] = [0, 1, '', 'test'];
console.log(onlyNumbers.every(is.string.or.number)); // true

const onlyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyStringList.every(is.string)); // false

const onlyNotEmptyStringList: string[] = [0, 1, '', 'test'];
console.log(onlyNotEmptyStringList.every(is.not.object)); // true

observable:pipe:filter

const stream$: Stream<boolean> = new Stream<boolean>();

stream$.pipe(filter(is.boolean)).subscribe(console.log); // true, false

stream$.next([false]); // Bad[README.ua.md](README.ua.md)
stream$.next(0); // Bad

stream$.next(true); // Good

stream$.next({ false: false }); // Bad

stream$.next(false); // Good

stream$.next(1); // Bad
stream$.next('false'); // Bad

Back to table of contents

🗃️ API

All methods return a boolean type

List of methods

Name - the name of a method that you can call to check certain types of data.

Tests - note the status of whether tests were written in the project to verify this method.

Status - we inform you that the method has been deleted, but if the tests are marked as OK, it means that this method is available, but has a different name and the tests are also written.

New name - informs that this method now has a new name.

List of wrappers and connections

New methods that are available through the package, but which are only declared in the package, but actually take data from outside the package.

Generale (841 methods)

HTML (80 methods)

Back to table of contents

➕ Additional

If you need to check arguments before executing a function, you can combine the package with @p4ck493/ts-type-guard.

Example

import { TypeGuard } from '@p4ck493/ts-type-guard';

class Person {
  #firstName: string;
  #secondName: string;
  #age: number;
  #somethink: any;

  @TypeGuard([is.string.not.empty])
  public setFirstName(firstName: string): void {
    this.#firstName = firstName;
  }

  @TypeGuard([is.string.not.empty])
  public setSecondName(secondName: string): void {
    this.#secondName = secondName;
  }

  // But it is not necessary to duplicate the check, if it is also the same for
  // the next argument, then you can not supplement it with new checks,
  // during the check, the previous one will be taken for the next argument.
  // @TypeGuard([is.string.not.empty]) - is equivalent
  @TypeGuard([is.string.not.empty, is.string.not.empty])
  public setSomeData(firstName: string, secondName: string): void {
    this.#firstName = firstName;
    this.#secondName = secondName;
  }

  // For optional argument use NULL value.
  @TypeGuard([is.string.not.empty, null])
  public setSomeData(firstName: string, age?: number): void {
    this.#firstName = firstName;
    this.#age = age;
  }

  @TypeGuard({
    result: [is.string],
  })
  public get firstName(): string {
    return this.#firstName;
  }

  @T