ts-generic-collections-linq

TypeScript library provides generic, strongly-typed, queryable collections

$3

* List
* Dictionary, SortedDictionary
* Queue, RandomizedQueue
* Stack

$3

``typescript
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;
}
``