From 6b6488be27a71d9dba0ae5959284ae9a18ae9230 Mon Sep 17 00:00:00 2001
From: Sam Wilkins <samwilkins333@gmail.com>
Date: Thu, 19 Sep 2019 14:13:59 -0400
Subject: extensions fixes and tracking albums

---
 src/client/util/UtilExtensions.ts | 259 --------------------------------------
 1 file changed, 259 deletions(-)
 delete mode 100644 src/client/util/UtilExtensions.ts

(limited to 'src/client/util/UtilExtensions.ts')

diff --git a/src/client/util/UtilExtensions.ts b/src/client/util/UtilExtensions.ts
deleted file mode 100644
index 1447e37cb..000000000
--- a/src/client/util/UtilExtensions.ts
+++ /dev/null
@@ -1,259 +0,0 @@
-module.exports.Batch = function <T, A>(batcher: Batcher<T, A>): T[][] {
-    if ("executor" in batcher) {
-        return this.predicateBatch(batcher);
-    } else {
-        return this.fixedBatch(batcher);
-    }
-};
-
-module.exports.BatchAsync = async function <T, A>(batcher: BatcherAsync<T, A>): Promise<T[][]> {
-    if ("executor" in batcher) {
-        return this.predicateBatchAsync(batcher);
-    } else {
-        return this.fixedBatch(batcher);
-    }
-};
-
-module.exports.PredicateBatch = function <T, A>(batcher: PredicateBatcher<T, A>): T[][] {
-    const batches: T[][] = [];
-    let batch: T[] = [];
-    const { executor, initial, persistAccumulator } = batcher;
-    let accumulator = initial;
-    for (let element of this) {
-        const { updated, makeNextBatch } = executor(element, accumulator);
-        accumulator = updated;
-        if (!makeNextBatch) {
-            batch.push(element);
-        } else {
-            batches.push(batch);
-            batch = [element];
-            if (!persistAccumulator) {
-                accumulator = initial;
-            }
-        }
-    }
-    batches.push(batch);
-    return batches;
-};
-
-module.exports.PredicateBatchAsync = async function <T, A>(batcher: PredicateBatcherAsync<T, A>): Promise<T[][]> {
-    const batches: T[][] = [];
-    let batch: T[] = [];
-    const { executor, initial, persistAccumulator } = batcher;
-    let accumulator: A = initial;
-    for (let element of this) {
-        const { updated, makeNextBatch } = await executor(element, accumulator);
-        accumulator = updated;
-        if (!makeNextBatch) {
-            batch.push(element);
-        } else {
-            batches.push(batch);
-            batch = [element];
-            if (!persistAccumulator) {
-                accumulator = initial;
-            }
-        }
-    }
-    batches.push(batch);
-    return batches;
-};
-
-enum Mode {
-    Balanced,
-    Even
-}
-
-module.exports.FixedBatch = function <T>(batcher: FixedBatcher): T[][] {
-    const batches: T[][] = [];
-    const length = this.length;
-    let i = 0;
-    if ("batchSize" in batcher) {
-        const { batchSize } = batcher;
-        while (i < this.length) {
-            const cap = Math.min(i + batchSize, length);
-            batches.push(this.slice(i, i = cap));
-        }
-    } else if ("batchCount" in batcher) {
-        let { batchCount, mode } = batcher;
-        const resolved = mode || Mode.Balanced;
-        if (batchCount < 1) {
-            throw new Error("Batch count must be a positive integer!");
-        }
-        if (batchCount === 1) {
-            return [this];
-        }
-        if (batchCount >= this.length) {
-            return this.map((element: T) => [element]);
-        }
-
-        let length = this.length;
-        let size: number;
-
-        if (length % batchCount === 0) {
-            size = Math.floor(length / batchCount);
-            while (i < length) {
-                batches.push(this.slice(i, i += size));
-            }
-        } else if (resolved === Mode.Balanced) {
-            while (i < length) {
-                size = Math.ceil((length - i) / batchCount--);
-                batches.push(this.slice(i, i += size));
-            }
-        } else {
-            batchCount--;
-            size = Math.floor(length / batchCount);
-            if (length % size === 0) {
-                size--;
-            }
-            while (i < size * batchCount) {
-                batches.push(this.slice(i, i += size));
-            }
-            batches.push(this.slice(size * batchCount));
-        }
-    }
-    return batches;
-};
-
-module.exports.ExecuteBatches = function <I, A>(batcher: Batcher<I, A>, handler: BatchHandlerSync<I>): void {
-    if (this.length) {
-        let completed = 0;
-        const batches = this.batch(batcher);
-        const quota = batches.length;
-        for (let batch of batches) {
-            const context: BatchContext = {
-                completedBatches: completed,
-                remainingBatches: quota - completed,
-            };
-            handler(batch, context);
-            completed++;
-        }
-    }
-};
-
-module.exports.ConvertInBatches = function <I, O, A>(batcher: Batcher<I, A>, handler: BatchConverterSync<I, O>): O[] {
-    if (!this.length) {
-        return [];
-    }
-    let collector: O[] = [];
-    let completed = 0;
-    const batches = this.batch(batcher);
-    const quota = batches.length;
-    for (let batch of batches) {
-        const context: BatchContext = {
-            completedBatches: completed,
-            remainingBatches: quota - completed,
-        };
-        collector.push(...handler(batch, context));
-        completed++;
-    }
-    return collector;
-};
-
-module.exports.ExecuteInBatchesAsync = async function <I, A>(batcher: BatcherAsync<I, A>, handler: BatchHandler<I>): Promise<void> {
-    if (this.length) {
-        let completed = 0;
-        const batches = await this.batchAsync(batcher);
-        const quota = batches.length;
-        for (let batch of batches) {
-            const context: BatchContext = {
-                completedBatches: completed,
-                remainingBatches: quota - completed,
-            };
-            await handler(batch, context);
-            completed++;
-        }
-    }
-};
-
-module.exports.ConvertInBatchesAsync = async function <I, O, A>(batcher: BatcherAsync<I, A>, handler: BatchConverter<I, O>): Promise<O[]> {
-    if (!this.length) {
-        return [];
-    }
-    let collector: O[] = [];
-    let completed = 0;
-    const batches = await this.batchAsync(batcher);
-    const quota = batches.length;
-    for (let batch of batches) {
-        const context: BatchContext = {
-            completedBatches: completed,
-            remainingBatches: quota - completed,
-        };
-        collector.push(...(await handler(batch, context)));
-        completed++;
-    }
-    return collector;
-};
-
-const convert = (interval: Interval) => {
-    const { magnitude, unit } = interval;
-    switch (unit) {
-        default:
-        case TimeUnit.Milliseconds:
-            return magnitude;
-        case TimeUnit.Seconds:
-            return magnitude * 1000;
-        case TimeUnit.Minutes:
-            return magnitude * 1000 * 60;
-    }
-};
-
-module.exports.ExecuteInBatchesAtInterval = async function <I, A>(batcher: BatcherAsync<I, A>, handler: BatchHandler<I>, interval: Interval): Promise<void> {
-    if (!this.length) {
-        return;
-    }
-    const batches = await this.batchAsync(batcher);
-    const quota = batches.length;
-    return new Promise<void>(async resolve => {
-        const iterator = batches[Symbol.iterator]();
-        let completed = 0;
-        while (true) {
-            const next = iterator.next();
-            await new Promise<void>(resolve => {
-                setTimeout(async () => {
-                    const batch = next.value;
-                    const context: BatchContext = {
-                        completedBatches: completed,
-                        remainingBatches: quota - completed,
-                    };
-                    await handler(batch, context);
-                    resolve();
-                }, convert(interval));
-            });
-            if (++completed === quota) {
-                break;
-            }
-        }
-        resolve();
-    });
-};
-
-module.exports.ConvertInBatchesAtInterval = async function <I, O, A>(batcher: BatcherAsync<I, A>, handler: BatchConverter<I, O>, interval: Interval): Promise<O[]> {
-    if (!this.length) {
-        return [];
-    }
-    let collector: O[] = [];
-    const batches = await this.batchAsync(batcher);
-    const quota = batches.length;
-    return new Promise<O[]>(async resolve => {
-        const iterator = batches[Symbol.iterator]();
-        let completed = 0;
-        while (true) {
-            const next = iterator.next();
-            await new Promise<void>(resolve => {
-                setTimeout(async () => {
-                    const batch = next.value;
-                    const context: BatchContext = {
-                        completedBatches: completed,
-                        remainingBatches: quota - completed,
-                    };
-                    collector.push(...(await handler(batch, context)));
-                    resolve();
-                }, convert(interval));
-            });
-            if (++completed === quota) {
-                resolve(collector);
-                break;
-            }
-        }
-    });
-};
\ No newline at end of file
-- 
cgit v1.2.3-70-g09d2