1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
// This test case is a condensed version of Angular 2's ListWrapper. Prior to #7448
// this would cause the compiler to run out of memory.
function outer<T>(x: T) {
class Inner {
static y: T = x;
}
return Inner;
}
let y: number = outer(5).y;
class ListWrapper2 {
static clone<T>(dit: typeof ListWrapper2, array: T[]): T[] { return array.slice(0); }
static reversed<T>(dit: typeof ListWrapper2, array: T[]): T[] {
var a = ListWrapper2.clone(dit, array);
return a;
}
}
namespace tessst {
/**
* Iterates through 'array' by index and performs the callback on each element of array until the callback
* returns a truthy value, then returns that value.
* If no such value is found, the callback is applied to each element of array and undefined is returned.
*/
export function funkyFor<T, U>(array: T[], callback: (element: T, index: number) => U): U {
if (array) {
for (let i = 0, len = array.length; i < len; i++) {
const result = callback(array[i], i);
if (result) {
return result;
}
}
}
return undefined;
}
}
interface Scanner {
scanRange<T>(start: number, length: number, callback: () => T): T;
}
class ListWrapper {
// JS has no way to express a statically fixed size list, but dart does so we
// keep both methods.
static createFixedSize(dit: typeof ListWrapper, size: number): any[] { return new Array(size); }
static createGrowableSize(dit: typeof ListWrapper, size: number): any[] { return new Array(size); }
static clone<T>(dit: typeof ListWrapper, array: T[]): T[] { return array.slice(0); }
static forEachWithIndex<T>(dit: typeof ListWrapper, array: T[], fn: (t: T, n: number) => void) {
for (var i = 0; i < array.length; i++) {
fn(array[i], i);
}
}
static first<T>(dit: typeof ListWrapper, array: T[]): T {
if (!array) return null;
return array[0];
}
static last<T>(dit: typeof ListWrapper, array: T[]): T {
if (!array || array.length == 0) return null;
return array[array.length - 1];
}
static indexOf<T>(dit: typeof ListWrapper, array: T[], value: T, startIndex: number = 0): number {
return array.indexOf(value, startIndex);
}
static contains<T>(dit: typeof ListWrapper, list: T[], el: T): boolean { return list.indexOf(el) !== -1; }
static reversed<T>(dit: typeof ListWrapper, array: T[]): T[] {
var a = ListWrapper.clone(dit, array);
let scanner: Scanner;
scanner.scanRange(3, 5, () => { });
return tessst.funkyFor(array, t => t.toString()) ? a.reverse() : a;
}
static concat(dit: typeof ListWrapper, a: any[], b: any[]): any[] { return a.concat(b); }
static insert<T>(dit: typeof ListWrapper, list: T[], index: number, value: T) { list.splice(index, 0, value); }
static removeAt<T>(dit: typeof ListWrapper, list: T[], index: number): T {
var res = list[index];
list.splice(index, 1);
return res;
}
static removeAll<T>(dit: typeof ListWrapper, list: T[], items: T[]) {
for (var i = 0; i < items.length; ++i) {
var index = list.indexOf(items[i]);
list.splice(index, 1);
}
}
static remove<T>(dit: typeof ListWrapper, list: T[], el: T): boolean {
var index = list.indexOf(el);
if (index > -1) {
list.splice(index, 1);
return true;
}
return false;
}
static clear(dit: typeof ListWrapper, list: any[]) { list.length = 0; }
static isEmpty(dit: typeof ListWrapper, list: any[]): boolean { return list.length == 0; }
static fill(dit: typeof ListWrapper, list: any[], value: any, start: number = 0, end: number = null) {
list.fill(value, start, end === null ? list.length : end);
}
static equals(dit: typeof ListWrapper, a: any[], b: any[]): boolean {
if (a.length != b.length) return false;
for (var i = 0; i < a.length; ++i) {
if (a[i] !== b[i]) return false;
}
return true;
}
static slice<T>(dit: typeof ListWrapper, l: T[], from: number = 0, to: number = null): T[] {
return l.slice(from, to === null ? undefined : to);
}
static splice<T>(dit: typeof ListWrapper, l: T[], from: number, length: number): T[] { return l.splice(from, length); }
static sort<T>(dit: typeof ListWrapper, l: T[], compareFn?: (a: T, b: T) => number) {
if (isPresent(compareFn)) {
l.sort(compareFn);
} else {
l.sort();
}
}
static toString<T>(dit: typeof ListWrapper, l: T[]): string { return l.toString(); }
static toJSON<T>(dit: typeof ListWrapper, l: T[]): string { return JSON.stringify(l); }
static maximum<T>(dit: typeof ListWrapper, list: T[], predicate: (t: T) => number): T {
if (list.length == 0) {
return null;
}
var solution: T = null;
var maxValue = -Infinity;
for (var index = 0; index < list.length; index++) {
var candidate = list[index];
if (isBlank(candidate)) {
continue;
}
var candidateValue = predicate(candidate);
if (candidateValue > maxValue) {
solution = candidate;
maxValue = candidateValue;
}
}
return solution;
}
}
let cloned = ListWrapper.clone(ListWrapper, [1,2,3,4]);
declare function isBlank(x: any): boolean;
declare function isPresent<T>(compareFn?: (a: T, b: T) => number): boolean;
interface Array<T> {
fill(value: any, start: number, end: number): void;
}
|
