TypeScript library provides strongly-typed, queryable collections.
npm install ts-generic-collections-linqtypescript
export interface IEnumerable {
elementAt(index: number) : T;
any(predicate?: (item: T)=> boolean) : boolean;
all(predicate?: (item: T)=> boolean) : boolean;
single(predicate?: (item: T)=> boolean) : T;
first(predicate?: (item: T)=> boolean) : T;
last(predicate?: (item: T)=> boolean) : T;
singleOrDefault(predicate: (item: T)=> boolean) : T;
firstOrDefault(predicate: (item: T)=> boolean) : T;
lastOrDefault(predicate: (item: T)=> boolean) : T;
where(predicate: (item: T)=> boolean) : IEnumerable;
select(predicate: (item: T)=> TResult) : IEnumerable;
selectMany(predicate: (item: T)=> Array) : IEnumerable;
join(outer: IEnumerable, conditionInner: (item: T)=> TMatch,
conditionOuter: (item: TOuter)=> TMatch, select: (x: T, y:TOuter)=> TResult, leftJoin?: boolean) : IEnumerable;
groupBy(predicate: (item: T) => Array) : IEnumerable>;
orderBy(comparer: IComparer) : IEnumerable;
distinct(comparer: IEqualityComparer) : IEnumerable;
union(list: IEnumerable) : IEnumerable;
reverse(): IEnumerable;
skip(no: number) : IEnumerable;
take(no: number) : IEnumerable;
sum(predicate: (item: T)=> number) : number;
avg(predicate: (item: T)=> number) : number;
min(predicate: (item: T)=> number) : number;
max(predicate: (item: T)=> number) : number;
count(predicate?: (item: T)=> boolean) : number;
forEach(predicate: (item: T)=> void) : void;
length: number;
toArray() : Array;
asEnumerable() : IEnumerable;
}
`
List
$3
`typescript
export interface IList extends IEnumerable {
add(item: T) : void;
addRange(items: T[]) : void;
remove(predicate: (item:T) => boolean) : void;
removeAt(index: number) : void;
clear() : void;
}
`
$3
Import the library:
`typescript
import { List, Dictionary } from 'ts-generic-collections-linq'
`
Below query gets the owners by the sex of their pets.
`typescript
let owners = new List();
let owner = new Owner();
owner.id = 1;
owner.name = "John Doe";
owners.add(owner);
owner = new Owner();
owner.id = 2;
owner.name = "Jane Doe";
owners.add(owner);
let pets = new List();
let pet = new Pet();
pet.ownerId = 2;
pet.name = "Sam";
pet.sex = Sex.M;
pets.add(pet);
pet = new Pet();
pet.ownerId = 1;
pet.name = "Jenny";
pet.sex = Sex.F;
pets.add(pet);
//query to get owners by the sex/gender of their pets
let ownersByPetSex = owners.join(pets, owner => owner.id, pet => pet.ownerId, (x, y) => new OwnerPet(x,y))
.groupBy(x => [x.pet.sex])
.select(x => new OwnersByPetSex(x.groups[0], x.list.select(x => x.owner)));
expect(ownersByPetSex.toArray().length === 2).toBeTruthy();
expect(ownersByPetSex.toArray()[0].sex == Sex.F).toBeTruthy();
expect(ownersByPetSex.toArray()[0].owners.length === 1).toBeTruthy();
expect(ownersByPetSex.toArray()[0].owners.toArray()[0].name == "John Doe").toBeTruthy();
expect(ownersByPetSex.toArray()[1].sex == Sex.M).toBeTruthy();
expect(ownersByPetSex.toArray()[1].owners.length == 1).toBeTruthy();
expect(ownersByPetSex.toArray()[1].owners.toArray()[0].name == "Jane Doe").toBeTruthy();
`
$3
`typescript
let jsonOwnerArray = '[{"id":1, "name": "John Doe"},{"id":2, "name": "Jane Doe"}]';
let ownerArray: Owner[] = JSON.parse(jsonOwnerArray);
let list = new List(ownerArray);
`
$3
`typescript
class Owner {
id: number;
name: string;
}
class Pet {
ownerId: number;
name: string;
sex: Sex;
}
enum Sex {
M,
F
}
class OwnerPet {
owner: Owner;
pet: Pet;
constructor(owner: Owner, pet: Pet) {
this.owner = owner;
this.pet = pet;
}
}
class OwnersByPetSex {
sex: Sex;
owners: IEnumerable;
constructor(sex: Sex, owners: IEnumerable) {
this.sex = sex;
this.owners = owners;
}
}
`
Dictionary
$3
`typescript
export interface IDictionary extends IEnumerable> {
add(key: TKey, value: TValue) : void;
addRange(items: KeyValuePair[]) : void;
remove(predicate: (item:KeyValuePair) => boolean) : void;
removeAt(index: number) : void;
clear() : void;
containsKey(key: TKey) : boolean;
containsValue(value: TValue) : boolean;
tryGetValue(key: TKey) : TValue;
}
`
$3
* sorted by Key
* uses IComparer\ to provide the sorted collection.
Queue
$3
`typescript
export interface IQueue {
clear() : void;
contains(item: T) : boolean;
dequeue() : T;
enqueue(item: T) : void;
peek(): T;
forEach(predicate: (item: T)=> void) : void;
toArray(): Array;
}
`
$3
* enqueue to the end.
* dequeue a random item.
* peek (but not dequeue) a random item.
* if you peek and then dequeue, the peeked item is dequeued.
Stack
$3
`typescript
export interface IStack {
clear() : void;
contains(item: T) : boolean;
pop() : T;
push(item: T) : void;
peek(): T;
forEach(predicate: (item: T)=> void) : void;
toArray(): Array;
}
``