@opi_pib/ts-utility

• Install
• Assert
  • Usage
    • TypeScript
• Logic
  • Is
• Models
  • Entity
  • Value object
• Types
  • Maybe
• Utils
  • stripHtml

Install

npm install @opi_pib/ts-utility

Assert

Usage

function add(x, y) {
	always(typeof x === "number", "Argument 'x' has to be a number.");
	always(typeof y === "number", "Argument 'y' has to be a number.");
	return x + y;
}

always() function throw an Error if the condition is false:

always(1 > 0); // ok
always(1 < 0); // throws Error

never() does the same but in reverse:

never(1 > 0); // throws Error
never(1 < 0); // ok

TypeScript

function always() are typed to assert that the condition you pass them are true, which gives you certainty that your variable is of a given type at runtime.

export declare function always(condition: boolean, code: string): asserts condition;

const x: unknown = someUntypedFunction();
always(typeof x === "string");
const y = x.toUpperCase(); // TypeScript knows that x must be a string, your IDE can suggest toUpperCase() method

Logic

Is

Static methods of this class will check type of provided value

Is.defined

Is.defined("123"); // true
Is.defined(null); // false
Is.defined(undefined); // false

Is.function

Checks if value is function

Is.function(() => {}); // true
Is.function(""); // false
Is.function(new Promise(() => "")); // false

Is.instanceOf

Checks if value is instance of value

class TestClass {}
Is.InstanceOf(TestClass, new TestClass()); // true
Is.InstanceOf(TestClass, 1); // false

Is.object

Checks if value is object

Is.object({}); // true
Is.object([]); // false
Is.object(() => {}); // false
Is.object(new Promise(() => "")); // false

Is.promise

Checks if value is promise

Is.promise({}); // false
Is.promise(new Promise(() => "")); // true

Is.url

Checks if value is valid url

Is.url("www.google.com"); // false
Is.url("https://google.com"); // true

Other types

Checks if provided value is of provided type

Is.date(new Date()); // true
Is.boolean(true); // true
Is.string(""); // true
Is.null(null); // true
Is.regexp(/someRegularExpression/i); // true
Is.regexp(new RegExp("someRegularExpression", "i")); // true
Is.array([]); // true
Is.number(0); // true
Is.number(NaN); // true
Is.number(Infinity); // true

Models

Entity

Entities are objects that we determine their equality through their identifier.

Example:

interface IdProps {
	id: string;
}

class Id extends ValueObject<IdProps> {
	private constructor(protected readonly props: IdProps) {
		super(props);
	}

	static create(id: string): Id {
		return new Id({ id });
	}
}

interface TestedEntityDto {
	id: Id;
	value: string;
}

interface TestedEntityProps {
	id: Id;
	value: string;
}

class TestedEntity extends Entity<TestedEntityProps> {
	private constructor(protected readonly props: TestedEntityProps) {
		super(props);
	}

	static create(testedEntityDto: TestedEntityDto): TestedEntity {
		return new TestedEntity(testedEntityDto);
	}
}

it("should equals by id", () => {
	const id1 = Id.create("123");
	const id2 = Id.create("123");
	const a = TestedEntity.create({ id: id1, value: "example1" });
	const b = TestedEntity.create({ id: id2, value: "example2" });

	expect(a.equals(b)).toBe(true);
});

it("should not equal if id1 not equals id2", () => {
	const id1 = Id.create("123");
	const id2 = Id.create("1234");
	const a = TestedEntity.create({ id: id1, value: "example" });
	const b = TestedEntity.create({ id: id2, value: "example" });

	expect(a.equals(b)).toBe(false);
});

Value object

ValueObjects are objects that we determine their equality through their structrual property.

Example:

interface TestedValueObjectProps {
	name: string;
	city: {
		name: string;
	};
}

class TestedValueObject extends ValueObject<TestedValueObjectProps> {
	private constructor(protected readonly props: TestedValueObjectProps) {
		super(props);
	}

	static create(name: string, cityName: string): TestedValueObject {
		return new TestedValueObject({ name, city: { name: cityName } });
	}
}

it("should equals by structure", () => {
	const a = TestedValueObject.create("name", "cityName");
	const b = TestedValueObject.create("name", "cityName");

	expect(a.equals(b)).toBe(true);
});

it("should not equals if structure is different", () => {
	const a = TestedValueObject.create("name", "cityName1");
	const b = TestedValueObject.create("name", "cityName2");

	expect(a.equals(b)).toBe(false);
});

Types

Maybe

Marks value as nullable, it can be T, undefined, null. It forces null check on every usage of value.

interface Example {
	a: string;
	b?: Maybe<string>;
}

const obj: Example = {
	a: "string",
	b: "maybeString",
};

const { a, b } = obj;

a.length; // Ok
b.length; // Error, b can be undefined

if (b != null) {
	b.length; // Ok
}

Utils

stripHtml

Removes HTML tags from string

stripHtml('<h1>Title</h1> <p>content</p><img src="">'); // 'Title content'