1.0.3 • Published 1 year ago

ts-primitive-types v1.0.3

Weekly downloads
-
License
MIT
Repository
-
Last release
1 year ago

ts-primitive-types

Description

This project provides a set of types and classes in TypeScript to work with booleans, numbers, and strings. It is designed to facilitate the manipulation of these types in TypeScript applications, offering a consistent and easy-to-use API.

Prerequisites

  • Node.js (>= version 22.0.0)
  • npm (>= version 10.5.0)

Installation with npm

To install the package, run:

npm install ts-primitive-types

Services you will use

ArrayBoolean methods

  • allBooleans(arr: boolean[]): boolean
  • countTrue(arr: boolean[]): number
  • countFalse(arr: boolean[]): number
  • allTrue(arr: boolean[]): boolean
  • allFalse(arr: boolean[]): boolean
  • anyTrue(arr: boolean[]): boolean
  • anyFalse(arr: boolean[]): boolean
  • toggle(arr: boolean[]): boolean[]
  • and(arr: boolean[]): boolean

  • or(arr: boolean[]): boolean

Usage:

const boolArray = [true, false, true, false, true];

// Check if all elements are booleans
console.log(ArrayBoolean.allBooleans(boolArray)); // Output: true

// Count the number of true values
console.log(ArrayBoolean.countTrue(boolArray)); // Output: 3

// Count the number of false values
console.log(ArrayBoolean.countFalse(boolArray)); // Output: 2

// Check if all elements are true
console.log(ArrayBoolean.allTrue(boolArray)); // Output: false

// Check if all elements are false
console.log(ArrayBoolean.allFalse(boolArray)); // Output: false

// Check if any element is true
console.log(ArrayBoolean.anyTrue(boolArray)); // Output: true

// Check if any element is false
console.log(ArrayBoolean.anyFalse(boolArray)); // Output: true

// Toggle all elements in the array
console.log(ArrayBoolean.toggle(boolArray)); // Output: [false, true, false, true, false]

// Logical AND of all elements (same as allTrue)
console.log(ArrayBoolean.and(boolArray)); // Output: false

// Logical OR of all elements (same as anyTrue)
console.log(ArrayBoolean.or(boolArray)); // Output: true

ArrayNumber methods

  • allNumbers(arr: number[]): boolean
  • uniqueNumbers(arr: number[]): boolean
  • sum(arr: number[]): number
  • average(arr: number[]): number
  • max(arr: number[]): number
  • min(arr: number[]): number
  • sortByAscending(arr: number[]): number[]
  • sortByDescending(arr: number[]): number[]
  • filterGreaterThan(arr: number[], threshold: number): number[]

Usage:

// Test array
const numArray = [3, 7, 1, 9, 4, 1];

// allNumbers: Check if all elements are numbers
console.log(ArrayNumber.allNumbers(numArray)); // Output: true

// uniqueNumbers: Check if all elements are unique
console.log(ArrayNumber.uniqueNumbers(numArray)); // Output: false

// sum: Calculate the sum of all elements
console.log(ArrayNumber.sum(numArray)); // Output: 25

// average: Calculate the average of all elements
console.log(ArrayNumber.average(numArray)); // Output: 4.166666666666667

// max: Find the maximum value in the array
console.log(ArrayNumber.max(numArray)); // Output: 9

// min: Find the minimum value in the array
console.log(ArrayNumber.min(numArray)); // Output: 1

// sortByAscending: Sort the array in ascending order
console.log(ArrayNumber.sortByAscending(numArray)); // Output: [1, 1, 3, 4, 7, 9]

// sortByDescending: Sort the array in descending order
console.log(ArrayNumber.sortByDescending(numArray)); // Output: [9, 7, 4, 3, 1, 1]

// filterGreaterThan: Filter elements greater than a specified threshold
console.log(ArrayNumber.filterGreaterThan(numArray, 4)); // Output: [7, 9]

ArrayObject methods

  • count(arr: T[]): number
  • toArray(set: Set<T>): T[]
  • allObjects(arr: T[]): boolean
  • merge(arr1: T[], arr2: T[]): T[]
  • sortByProperty(arr: T[], prop: K): T[]
  • filterByProperty(arr: T[], prop: K, value: T[K]): T[]
  • findFirst(arr: T[], prop: K, value: T[K]): T | undefined

Usage:

// Test array of objects
const objArray = [
  { id: 1, name: 'John', age: 30 },
  { id: 2, name: 'Jane', age: 25 },
  { id: 3, name: 'Doe', age: 35 },
  { id: 4, name: 'Alice', age: 28 },
];

// allObjects: Check if all elements are valid objects
ArrayObject.allObjects(objArray); 
// Output: true

// filterByProperty: Filter objects by a specific property value
ArrayObject.filterByProperty(objArray, 'name', 'Jane'); 
// Output: 
[{ id: 2, name: 'Jane', age: 25 }]

// sortByProperty: Sort objects by a specific property
ArrayObject.sortByProperty(objArray, 'age'); 
// Output: 
[
  { id: 2, name: "Jane", age: 25 },
  { id: 4, name: "Alice", age: 28 },
  { id: 1, name: "John", age: 30 },
  { id: 3, name: "Doe", age: 35 },
];


// count: Count the number of objects
console.log(ArrayObject.count(objArray)); // Output: 4

// toArray: Convert a set of objects to an array
const objSet = new Set(objArray);
console.log(ArrayObject.toArray(objSet)); 
// Output: 
[
  { id: 1, name: "John", age: 30 },
  { id: 2, name: "Jane", age: 25 },
  { id: 3, name: "Doe", age: 35 },
  { id: 4, name: "Alice", age: 28 },
];


// merge: Merge two arrays of objects
const objArray2 = [
  { id: 5, name: 'Bob', age: 32 },
  { id: 6, name: 'Eve', age: 27 },
];
console.log(ArrayObject.merge(objArray, objArray2)); 
// Output: 
[
  { id: 1, name: "John", age: 30 },
  { id: 2, name: "Jane", age: 25 },
  { id: 3, name: "Doe", age: 35 },
  { id: 4, name: "Alice", age: 28 },
  { id: 5, name: "Bob", age: 32 },
  { id: 6, name: "Eve", age: 27 },
];


// findFirst: Find the first object with a specific property value
console.log(ArrayObject.findFirst(objArray, 'id', 3)); 
// Output: 
{ id: 3, name: 'Doe', age: 35 }

ArrayString methods

  • allStrings(arr: string[]): boolean
  • uniqueStrings(arr: string[]): boolean
  • length(arr: string[]): number
  • setToArray(set: Set<string>): string[]
  • sortByLength(arr: string[]): string[]
  • reverse(arr: string[]): string[]
  • concatenate(arr1: string[], arr2: string[]): string[]
  • filterByPrefix(arr: string[], prefix: string): string[]

Usage:

// Test array of strings
const strArray = ['apple', 'banana', 'cherry', 'date', 'banana'];

// allStrings: Check if all elements are strings
console.log(ArrayString.allStrings(strArray)); // Output: true

// uniqueStrings: Check if all elements are unique strings
console.log(ArrayString.uniqueStrings(strArray)); // Output: false

// length: Get the length of the array
console.log(ArrayString.length(strArray)); // Output: 5

// setToArray: Convert a set of strings to an array
const strSet = new Set(strArray);
console.log(ArrayString.setToArray(strSet)); // Output: 
['apple', 'banana', 'cherry', 'date']

// sortByLength: Sort strings by their length
console.log(ArrayString.sortByLength(strArray)); // Output: 
['date', 'apple', 'banana', 'cherry', 'banana']

// reverse: Reverse the order of strings in the array
console.log(ArrayString.reverse(strArray)); // Output: 
['banana', 'date', 'cherry', 'banana', 'apple']

// concatenate: Concatenate two arrays of strings
const strArray2 = ['elderberry', 'fig'];
console.log(ArrayString.concatenate(strArray, strArray2)); // Output: 
['apple', 'banana', 'cherry', 'date', 'banana', 'elderberry', 'fig']

// filterByPrefix: Filter strings by a prefix
console.log(ArrayString.filterByPrefix(strArray, 'b')); // Output: 
['banana', 'banana']

TypeBool methods

  • IsBoolean(x: any): boolean
  • IsNotNullOrUndefined(x: any): boolean
  • IsTrue(x: boolean): boolean
  • IsFalse(x: boolean): boolean
  • ToBoolean(x: any): boolean
  • IsStrictBoolean(x: any): boolean
  • IsTruthy(x: any): boolean
  • IsFalsy(x: any): boolean

Usage:

// Test values
const value1 = true;
const value2 = false;
const value3 = 0;
const value4 = null;
const value5 = undefined;

// IsBoolean: Check if a value is a boolean
console.log(TypeBoolean.IsBoolean(value1)); // Output: true

// IsNotNullOrUndefined: Check if a value is neither null nor undefined
console.log(TypeBoolean.IsNotNullOrUndefined(value1)); // Output: true
console.log(TypeBoolean.IsNotNullOrUndefined(value4)); // Output: false

// IsTrue: Check if a boolean value is true
console.log(TypeBoolean.IsTrue(value1)); // Output: true

// IsFalse: Check if a boolean value is false
console.log(TypeBoolean.IsFalse(value2)); // Output: true

// ToBoolean: Convert a value to a boolean
console.log(TypeBoolean.ToBoolean(value3)); // Output: false

// IsStrictBoolean: Check if a value is strictly a boolean (true or false)
console.log(TypeBoolean.IsStrictBoolean(value1)); // Output: true
console.log(TypeBoolean.IsStrictBoolean(value3)); // Output: false

// IsTruthy: Check if a value is truthy (convertible to true)
console.log(TypeBoolean.IsTruthy(value1)); // Output: true
console.log(TypeBoolean.IsTruthy(value3)); // Output: false

// IsFalsy: Check if a value is falsy (convertible to false)
console.log(TypeBoolean.IsFalsy(value2)); // Output: true
console.log(TypeBoolean.IsFalsy(value3)); // Output: true

TypeClass methods

  • HasMethod(classInstance: any, methodName: string): boolean
  • HasProperty(classInstance: any, propertyName: string): boolean
  • InheritsFrom(classInstance: any, baseClass: Function): boolean
  • HasMethods(classInstance: any, methodNames: string[]): boolean
  • HasProperties( classInstance: any, propertyNames: string[] ): boolean

Usage:

// Example class
class ExampleClass {
  public method1() {
    console.log('Method 1');
  }

  public method2() {
    console.log('Method 2');
  }

  public property1 = 'Property 1';
}

// Instantiate the example class
const exampleInstance = new ExampleClass();

// Test method and property names
const methodNames = ['method1', 'method2'];
const propertyNames = ['property1', 'property2']; // property2 does not exist

// HasMethod: Check if the instance has a specific method
console.log(TypeClass.HasMethod(exampleInstance, 'method1')); // Output: true

// HasProperty: Check if the instance has a specific property
console.log(TypeClass.HasProperty(exampleInstance, 'property1')); // Output: true

// InheritsFrom: Check if the instance inherits from a specific base class
console.log(TypeClass.InheritsFrom(exampleInstance, ExampleClass)); // Output: true

// HasMethods: Check if the instance has all specified methods
console.log(TypeClass.HasMethods(exampleInstance, methodNames)); // Output: true

// HasProperties: Check if the instance has all specified properties
console.log(TypeClass.HasProperties(exampleInstance, propertyNames)); // Output: false

TypeNumber methods

  • IsNumber(x: any): boolean
  • IsNotNaN(num: number): boolean
  • IsInteger(num: number): boolean
  • IsPositive(num: number): boolean
  • IsNegative(num: number): boolean
  • IsInRange(num: number, min: number, max: number): boolean
  • IsOdd(num: number): boolean
  • IsEven(num: number): boolean
  • MaxDecimals(num: number, maxDecimals: number): boolean

Usage:

// Test numbers
const num1 = 42;
const num2 = 3.14;
const num3 = NaN;
const num4 = -10;
const num5 = 7;

// IsNumber: Check if a value is a number and not NaN
console.log(TypeNumber.IsNumber(num1)); // Output: true
console.log(TypeNumber.IsNumber(num3)); // Output: false

// IsNotNaN: Check if a number is not NaN
console.log(TypeNumber.IsNotNaN(num2)); // Output: true
console.log(TypeNumber.IsNotNaN(num3)); // Output: false

// IsInteger: Check if a number is an integer
console.log(TypeNumber.IsInteger(num1)); // Output: true
console.log(TypeNumber.IsInteger(num2)); // Output: false

// IsPositive: Check if a number is positive
console.log(TypeNumber.IsPositive(num1)); // Output: true
console.log(TypeNumber.IsPositive(num4)); // Output: false

// IsNegative: Check if a number is negative
console.log(TypeNumber.IsNegative(num4)); // Output: true
console.log(TypeNumber.IsNegative(num1)); // Output: false

// IsInRange: Check if a number is within a specified range
console.log(TypeNumber.IsInRange(num5, 1, 10)); // Output: true
console.log(TypeNumber.IsInRange(num4, 0, 5)); // Output: false

// IsOdd: Check if a number is odd
console.log(TypeNumber.IsOdd(num5)); // Output: true
console.log(TypeNumber.IsOdd(num4)); // Output: false

// IsEven: Check if a number is even
console.log(TypeNumber.IsEven(num4)); // Output: true
console.log(TypeNumber.IsEven(num5)); // Output: false

// MaxDecimals: Check if a number has a maximum number of decimal places
console.log(TypeNumber.MaxDecimals(num2, 2)); // Output: true
console.log(TypeNumber.MaxDecimals(num2, 0)); // Output: false

TypeString methods

  • IsString(x: any): boolean
  • IsNotEmpty(str: string): boolean
  • NoSpecialCharacters(str: string): boolean
  • FirstLetterUppercase(str: string): boolean
  • MinLength(str: string, min: number): boolean
  • MaxLength(str: string, max: number): boolean
  • OnlyLetters(str: string): boolean
  • OnlyNumbers(str: string): boolean
  • IsAlphanumeric(str: string): boolean
  • IsEmail(str: string): boolean
  • NoConsecutiveSpaces(str: string): boolean
  • NoLeadingOrTrailingSpaces(str: string): boolean

Usage:

// Test strings
const str1 = 'Hello';
const str2 = '12345';
const str3 = 'abc123';
const str4 = '   Valid String   ';
const str5 = 'invalid_email@example';

// IsString: Check if a value is a string
console.log(TypeString.IsString(str1)); // Output: true
console.log(TypeString.IsString(123)); // Output: false

// IsNotEmpty: Check if a string is not empty (after trimming)
console.log(TypeString.IsNotEmpty(str1)); // Output: true
console.log(TypeString.IsNotEmpty('   ')); // Output: false

// NoSpecialCharacters: Check if a string contains no special characters
console.log(TypeString.NoSpecialCharacters(str2)); // Output: true
console.log(TypeString.NoSpecialCharacters(str3)); // Output: true
console.log(TypeString.NoSpecialCharacters(str4)); // Output: false

// FirstLetterUppercase: Check if the first letter of a string is uppercase
console.log(TypeString.FirstLetterUppercase(str1)); // Output: true
console.log(TypeString.FirstLetterUppercase('lowercase')); // Output: false

// MinLength: Check if a string has at least a specified minimum length
console.log(TypeString.MinLength(str1, 5)); // Output: true
console.log(TypeString.MinLength(str2, 6)); // Output: false

// MaxLength: Check if a string does not exceed a specified maximum length
console.log(TypeString.MaxLength(str1, 10)); // Output: true
console.log(TypeString.MaxLength(str2, 4)); // Output: false

// OnlyLetters: Check if a string contains only letters
console.log(TypeString.OnlyLetters(str1)); // Output: true
console.log(TypeString.OnlyLetters(str2)); // Output: false

// OnlyNumbers: Check if a string contains only numbers
console.log(TypeString.OnlyNumbers(str2)); // Output: true
console.log(TypeString.OnlyNumbers(str3)); // Output: false

// IsAlphanumeric: Check if a string is alphanumeric (only letters and numbers)
console.log(TypeString.IsAlphanumeric(str2)); // Output: true
console.log(TypeString.IsAlphanumeric(str3)); // Output: true
console.log(TypeString.IsAlphanumeric(str4)); // Output: false

// IsEmail: Check if a string is a valid email address
console.log(TypeString.IsEmail('valid_email@example.com')); // Output: true
console.log(TypeString.IsEmail(str5)); // Output: false

// NoConsecutiveSpaces: Check if a string has no consecutive spaces
console.log(TypeString.NoConsecutiveSpaces(str4)); // Output: false
console.log(TypeString.NoConsecutiveSpaces('No  consecutive   spaces')); // Output: true

// NoLeadingOrTrailingSpaces: Check if a string has no leading or trailing spaces
console.log(TypeString.NoLeadingOrTrailingSpaces(str1)); // Output: true
console.log(TypeString.NoLeadingOrTrailingSpaces(str4)); // Output: false

Happy conding!

primitivetypesTypeScriptstringbooleannumberArrayBooleanArrayNumberArrayObjectArrayStringTypeBoolTypeClassTypeNumberTypeString
1.0.3

1 year ago

1.0.2

1 year ago

1.0.1

1 year ago

1.0.0

1 year ago