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
|
interface String {
ReplaceAll(toReplace: string, replacement: string): string;
Truncate(length: number, replacement: string): String;
removeTrailingNewlines(): string;
hasNewline(): boolean;
}
const extensions = require(".././/.//../util/UtilExtensions");
String.prototype.ReplaceAll = function (toReplace: string, replacement: string): string {
var target = this;
return target.split(toReplace).join(replacement);
};
String.prototype.Truncate = function (length: number, replacement: string): String {
var target = this;
if (target.length >= length) {
target = target.slice(0, Math.max(0, length - replacement.length)) + replacement;
}
return target;
};
type BatchConverterSync<I, O> = (batch: I[], isFullBatch: boolean) => O[];
type BatchHandlerSync<I> = (batch: I[], isFullBatch: boolean) => void;
type BatchConverterAsync<I, O> = (batch: I[], isFullBatch: boolean) => Promise<O[]>;
type BatchHandlerAsync<I> = (batch: I[], isFullBatch: boolean) => Promise<void>;
type BatchConverter<I, O> = BatchConverterSync<I, O> | BatchConverterAsync<I, O>;
type BatchHandler<I> = BatchHandlerSync<I> | BatchHandlerAsync<I>;
interface Array<T> {
batch(batchSize: number): T[][];
batchedForEach(batchSize: number, handler: BatchHandlerSync<T>): void;
batchedMap<O>(batchSize: number, handler: BatchConverterSync<T, O>): O[];
batchedForEachAsync(batchSize: number, handler: BatchHandler<T>): Promise<void>;
batchedMapAsync<O>(batchSize: number, handler: BatchConverter<T, O>): Promise<O[]>;
batchedForEachInterval(batchSize: number, handler: BatchHandler<T>, interval: number): Promise<void>;
batchedMapInterval<O>(batchSize: number, handler: BatchConverter<T, O>, interval: number): Promise<O[]>;
lastElement(): T;
}
Array.prototype.batch = extensions.Batch;
Array.prototype.batchedForEach = extensions.ExecuteInBatches;
Array.prototype.batchedMap = extensions.ConvertInBatches;
Array.prototype.batchedForEachAsync = extensions.ExecuteInBatchesAsync;
Array.prototype.batchedMapAsync = extensions.ConvertInBatchesAsync;
Array.prototype.batchedForEachInterval = extensions.ExecuteInBatchesAtInterval;
Array.prototype.batchedMapInterval = extensions.ConvertInBatchesAtInterval;
Array.prototype.lastElement = function <T>() {
if (!this.length) {
return undefined;
}
const last: T = this[this.length - 1];
return last;
};
interface Math {
log10(val: number): number;
}
Math.log10 = function (val: number): number {
return Math.log(val) / Math.LN10;
};
declare interface ObjectConstructor {
assign(...objects: Object[]): Object;
}
|
