Package Exports
- ts-generic-collections-linq
This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (ts-generic-collections-linq) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.
Readme
ts-generic-collections-linq
TypeScript library provides generic, strongly-typed, queryable collections
The generic collections are:
- List
- Dictionary, SortedDictionary
- Queue, RandomizedQueue
- Stack
List, Dictionary collections implement interface IEnumerable<T>
export interface IEnumerable<T> {
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<T>;
select<TResult>(predicate: (item: T)=> TResult) : IEnumerable<TResult>;
selectMany<TResult>(predicate: (item: T)=> Array<TResult>) : IEnumerable<TResult>;
join<TOuter, TMatch, TResult>(outer: IEnumerable<TOuter>, conditionInner: (item: T)=> TMatch,
conditionOuter: (item: TOuter)=> TMatch, select: (x: T, y:TOuter)=> TResult, leftJoin?: boolean) : IEnumerable<TResult>;
groupBy(predicate: (item: T) => Array<any>) : IEnumerable<IGroup<T>>;
orderBy(comparer: IComparer<T>) : IEnumerable<T>;
distinct(comparer: IEqualityComparer<T>) : IEnumerable<T>;
union(list: IEnumerable<T>) : IEnumerable<T>;
reverse(): IEnumerable<T>;
skip(no: number) : IEnumerable<T>;
take(no: number) : IEnumerable<T>;
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<T>;
asEnumerable() : IEnumerable<T>;
}
List
List implements interface IList<T>
export interface IList<T> extends IEnumerable<T> {
add(item: T) : void;
addRange(items: T[]) : void;
remove(predicate: (item:T) => boolean) : void;
removeAt(index: number) : void;
clear() : void;
}
You can create queries like below
Import the library:
import { List, Dictionary } from 'ts-generic-collections-linq'
Below query gets the owners by the sex of their pets.
let owners = new List<Owner>();
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<Pet>();
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();
You can instantiate a List from JSON as shown below
let jsonOwnerArray = '[{"id":1, "name": "John Doe"},{"id":2, "name": "Jane Doe"}]';
let ownerArray: Owner[] = JSON.parse(jsonOwnerArray);
let list = new List(ownerArray);
Entities for above example are
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<Owner>;
constructor(sex: Sex, owners: IEnumerable<Owner>) {
this.sex = sex;
this.owners = owners;
}
}
Dictionary
Dictionary, SortedDictionary implement IDictionary<TKey, TValue>
export interface IDictionary<TKey, TValue> extends IEnumerable<KeyValuePair<TKey, TValue>> {
add(key: TKey, value: TValue) : void;
addRange(items: KeyValuePair<TKey, TValue>[]) : void;
remove(predicate: (item:KeyValuePair<TKey, TValue>) => boolean) : void;
removeAt(index: number) : void;
clear() : void;
containsKey(key: TKey) : boolean;
containsValue(value: TValue) : boolean;
tryGetValue(key: TKey) : TValue;
}
SortedDictionary
- sorted by Key
- uses IComparer<TKey> to provide the sorted collection.
Queue
Queue, RandomizedQueue implement interface IQueue<T>
export interface IQueue<T> {
clear() : void;
contains(item: T) : boolean;
dequeue() : T;
enqueue(item: T) : void;
peek(): T;
forEach(predicate: (item: T)=> void) : void;
toArray(): Array<T>;
}
RandomizedQueue
- 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
Stack implements interface IStack<T>
export interface IStack<T> {
clear() : void;
contains(item: T) : boolean;
pop() : T;
push(item: T) : void;
peek(): T;
forEach(predicate: (item: T)=> void) : void;
toArray(): Array<T>;
}