diff --git a/lazy.js/lazy.js-test.ts b/lazy.js/lazy.js-test.ts new file mode 100644 index 000000000..b5252a1bc --- /dev/null +++ b/lazy.js/lazy.js-test.ts @@ -0,0 +1,194 @@ +/// + +var sequence:LazyJS.Sequence; +var arraySeq:LazyJS.ArrayLikeSequence; +var objectSeq:LazyJS.ObjectLikeSequence; +var asyncSeq:LazyJS.AsyncSequence; +var stringSeq:LazyJS.StringLikeSequence; + +var obj:Object; +var bool:boolean; +var num:number; +var str:string; +var x:any = null; +var arr:any[]; +var exp:RegExp; +var strArr:string[]; +var numArr:string[]; + +function fnCallback():void { +} + +function fnErrorCallback(error:any):void { + +} + +function fnValueCallback(value:any):void { +} + +function fnGetKeyCallback(value:any):string { + return ''; +} + +function fnTestCallback(value:any):boolean { + return false; +} + +function fnMapCallback(value:any):any { + return null; +} + +function fnMapStringCallback(value:string):string { + return ''; +} + +function fnNumberCallback(value:any):number { + return 0; +} + +function fnMemoCallback(memo:any, value:any):any { + return null; +} + +function fnGeneratorCallback(index:number):any { + return null; +} + +// Lazy + +arraySeq = Lazy([]); +objectSeq = Lazy({}); +stringSeq = Lazy(''); + +// Strict + +var Strict = Lazy.strict(); +arraySeq = Strict([1,2,num]).pop(); + +// Sequence + +asyncSeq = sequence.async(num); +sequence = sequence.chunk(num); +sequence = sequence.compact(); +sequence = sequence.concat(arr); +sequence = sequence.consecutive(num); +bool = sequence.contains(x); +sequence = sequence.countBy(str); +sequence = sequence.countBy(fnGetKeyCallback); +sequence = sequence.dropWhile(fnTestCallback); +sequence = sequence.each(fnValueCallback); +bool = sequence.every(fnTestCallback); +sequence = sequence.filter(fnTestCallback); +sequence = sequence.find(fnTestCallback); +sequence = sequence.findWhere(obj); + +x = sequence.first(); +sequence= sequence.first(num); + +sequence = sequence.flatten(); +objectSeq = sequence.groupBy(fnGetKeyCallback); +sequence = sequence.indexOf(x); +sequence = sequence.initial(); +sequence = sequence.initial(num); +sequence = sequence.intersection(arr); +sequence = sequence.invoke(str); +bool = sequence.isEmpty(); +str = sequence.join(); +str = sequence.join(str); + +x = sequence.last(); +sequence = sequence.last(num); + +sequence = sequence.lastIndexOf(x); +sequence = sequence.map(fnMapCallback); +x = sequence.max(); +x = sequence.max(fnNumberCallback); +x = sequence.min(); +x = sequence.min(fnNumberCallback); +sequence = sequence.pluck(str); +x = sequence.reduce(fnMemoCallback); +x = sequence.reduce(fnMemoCallback, x); +x = sequence.reduceRight(fnMemoCallback, x); +sequence = sequence.reject(fnTestCallback); +sequence = sequence.rest(num); +sequence = sequence.reverse(); +sequence = sequence.shuffle(); +bool = sequence.some(); +bool = sequence.some(fnTestCallback); +sequence = sequence.sortBy(fnNumberCallback); +sequence = sequence.sortedIndex(x); +sequence = sequence.sum(); +sequence = sequence.sum(fnNumberCallback); +sequence = sequence.takeWhile(fnTestCallback); +sequence = sequence.union(arr); +sequence = sequence.uniq(); +sequence = sequence.where(obj); +sequence = sequence.without(arr); +sequence = sequence.zip(arr); + +arr = sequence.toArray(); +obj = sequence.toObject(); + + +// ArrayLikeSequence + +arraySeq = arraySeq.concat(); +arraySeq = arraySeq.first(); +arraySeq = arraySeq.first(num); +x = arraySeq.get(num); +num = arraySeq.length(); +arraySeq = arraySeq.map(fnMapCallback); +arraySeq = arraySeq.pop(); +arraySeq = arraySeq.rest(); +arraySeq = arraySeq.rest(num); +arraySeq = arraySeq.reverse(); +arraySeq = arraySeq.shift(); +arraySeq = arraySeq.slice(num); +arraySeq = arraySeq.slice(num, num); + + +// ObjectLikeSequence + +objectSeq = objectSeq.defaults(obj); +sequence = objectSeq.functions(); +objectSeq = objectSeq.get(str); +objectSeq = objectSeq.invert(); +sequence = objectSeq.keys(); +objectSeq = objectSeq.omit(strArr); +sequence = objectSeq.pairs(); +objectSeq = objectSeq.pick(strArr); +arr = objectSeq.toArray(); +obj = objectSeq.toObject(); +sequence = objectSeq.values(); + + +// StringLikeSequence + +str = stringSeq.charAt(num); +num = stringSeq.charCodeAt(num); +bool = stringSeq.contains(str); +bool = stringSeq.endsWith(str); + +str = stringSeq.first(); +stringSeq = stringSeq.first(num); + +num = stringSeq.indexOf(str); +num = stringSeq.indexOf(str, num); + +str = stringSeq.last(); +stringSeq = stringSeq.last(num); + +num = stringSeq.lastIndexOf(str); +num = stringSeq.lastIndexOf(str, num); +stringSeq = stringSeq.mapString(fnMapStringCallback); +stringSeq = stringSeq.match(exp); +stringSeq = stringSeq.reverse(); + +sequence = stringSeq.split(str); +sequence = stringSeq.split(exp); + +bool = stringSeq.startsWith(str); +stringSeq = stringSeq.substring(num); +stringSeq = stringSeq.substring(num, num); +stringSeq = stringSeq.toLowerCase(); +stringSeq = stringSeq.toUpperCase(); diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts new file mode 100644 index 000000000..650ffd079 --- /dev/null +++ b/lazy.js/lazy.js.d.ts @@ -0,0 +1,244 @@ +// Type definitions for js 0.3.2 +// Project: https://github.com/dtao/lazy.js/ +// Definitions by: Bart van der Schoor +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module LazyJS { + + interface LazyStatic { + (value:string):StringLikeSequence; + (value:any[]):ArrayLikeSequence; + (value:Object):ObjectLikeSequence; + (value:ArrayLike):ArrayLikeSequence; + + strict():LazyStatic; + + generate(generatorFn:GeneratorCallback, length?:number):GeneratedSequence; + + range(to:number):GeneratedSequence; + range(from:number, to:number, step?:number):GeneratedSequence; + + repeat(value:any, count?:number):GeneratedSequence; + + on(eventType:string):Sequence; + + readFile(path:string):StringLikeSequence; + makeHttpRequest(path:string):StringLikeSequence; + } + + interface ArrayLike { + length:number; + } + + interface Callback { + ():void; + } + + interface ErrorCallback { + (error:any):void; + } + + interface ValueCallback { + (value:any):void; + } + + interface GetKeyCallback { + (value:any):string; + } + + interface TestCallback { + (value:any):boolean; + } + + interface MapCallback { + (value:any):any; + } + + interface MapStringCallback { + (value:string):string; + } + + interface NumberCallback { + (value:any):number; + } + + interface MemoCallback { + (memo:any, value:any):any; + } + + interface GeneratorCallback { + (index:number):any; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + interface Iterator { + new(sequence:Sequence):Iterator; + current():any; + moveNext():boolean; + } + + interface GeneratedSequence extends Sequence { + new(generatorFn:GeneratorCallback, length:number):GeneratedSequence; + length():number; + } + + interface AsyncSequence extends SequenceBase { + each(callback:ValueCallback):AsyncHandle; + } + + interface AsyncHandle { + cancel():void; + onComplete(callback:Callback):void; + onError(callback:ErrorCallback):void; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + module Sequence { + function define(methodName:string[], overrides:Object):Function; + } + + interface Sequence extends SequenceBase { + each(eachFn:ValueCallback):Sequence; + } + + interface SequenceBase extends SequenceBaser { + first():any; + first(count:number):Sequence; + indexOf(value:any, startIndex?:number):Sequence; + + last():any; + last(count:number):Sequence; + lastIndexOf(value:any):Sequence; + + reverse():Sequence; + } + + interface SequenceBaser { + // TODO improve define() (needs ugly overload) + async(interval:number):AsyncSequence; + chunk(size:number):Sequence; + compact():Sequence; + concat(var_args:any[]):Sequence; + consecutive(length:number):Sequence; + contains(value:any):boolean; + countBy(propertyName:string):Sequence; + countBy(keyFn:GetKeyCallback):Sequence; + dropWhile(predicateFn:TestCallback):Sequence; + every(predicateFn:TestCallback):boolean; + filter(predicateFn:TestCallback):Sequence; + find(predicateFn:TestCallback):Sequence; + findWhere(properties:Object):Sequence; + + flatten():Sequence; + groupBy(keyFn:GetKeyCallback):ObjectLikeSequence; + initial(count?:number):Sequence; + intersection(var_args:any[]):Sequence; + invoke(methodName:string):Sequence; + isEmpty():boolean; + join(delimiter?:string):string; + map(mapFn:MapCallback):Sequence; + max(valueFn?:NumberCallback):any; + min(valueFn?:NumberCallback):any; + pluck(propertyName:string):Sequence; + reduce(aggregatorFn:MemoCallback, memo?:any):any; + reduceRight(aggregatorFn:MemoCallback, memo:any):any; + reject(predicateFn:TestCallback):Sequence; + rest(count?:number):Sequence; + shuffle():Sequence; + some(predicateFn?:TestCallback):boolean; + sortBy(sortFn:NumberCallback):Sequence; + sortedIndex(value:any):Sequence; + sum(valueFn?:NumberCallback):Sequence; + takeWhile(predicateFn:TestCallback):Sequence; + union(var_args:any[]):Sequence; + uniq():Sequence; + where(properties:Object):Sequence; + without(var_args:any[]):Sequence; + zip(var_args:any[]):Sequence; + + toArray():any[]; + toObject():Object; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + module ArrayLikeSequence { + function define(methodName:string[], overrides:Object):Function; + } + + interface ArrayLikeSequence extends Sequence { + // define()X; + concat():ArrayLikeSequence; + first(count?:number):ArrayLikeSequence; + get(index:number):any; + length():number; + map(mapFn:MapCallback):ArrayLikeSequence; + pop():ArrayLikeSequence; + rest(count?:number):ArrayLikeSequence; + reverse():ArrayLikeSequence; + shift():ArrayLikeSequence; + slice(begin:number, end?:number):ArrayLikeSequence; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + module ObjectLikeSequence { + function define(methodName:string[], overrides:Object):Function; + } + + interface ObjectLikeSequence extends Sequence { + assign(other:Object):ObjectLikeSequence; + // throws error + //async():X; + defaults(defaults:Object):ObjectLikeSequence; + functions():Sequence; + get(property:string):ObjectLikeSequence; + invert():ObjectLikeSequence; + keys():Sequence; + omit(properties:string[]):ObjectLikeSequence; + pairs():Sequence; + pick(properties:string[]):ObjectLikeSequence; + toArray():any[]; + toObject():Object; + values():Sequence; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + module StringLikeSequence { + function define(methodName:string[], overrides:Object):Function; + } + + interface StringLikeSequence extends SequenceBaser { + charAt(index:number):string; + charCodeAt(index:number):number; + contains(value:string):boolean; + endsWith(suffix:string):boolean; + + first():string; + first(count:number):StringLikeSequence; + + indexOf(substring:string, startIndex?:number):number; + + last():string; + last(count:number):StringLikeSequence; + + lastIndexOf(substring:string, startIndex?:number):number; + mapString(mapFn:MapStringCallback):StringLikeSequence; + match(pattern:RegExp):StringLikeSequence; + reverse():StringLikeSequence; + + split(delimiter:string):Sequence; + split(delimiter:RegExp):Sequence; + + startsWith(prefix:string):boolean; + substring(start:number, stop?:number):StringLikeSequence; + toLowerCase():StringLikeSequence; + toUpperCase():StringLikeSequence; + } +} + +declare var Lazy:LazyJS.LazyStatic; +