aboutsummaryrefslogtreecommitdiff
path: root/src/client
diff options
context:
space:
mode:
Diffstat (limited to 'src/client')
-rw-r--r--src/client/apis/google_docs/GooglePhotosClientUtils.ts4
-rw-r--r--src/client/northstar/utils/Extensions.ts83
-rw-r--r--src/client/util/UtilExtensions.ts259
-rw-r--r--src/client/views/Main.tsx13
4 files changed, 5 insertions, 354 deletions
diff --git a/src/client/apis/google_docs/GooglePhotosClientUtils.ts b/src/client/apis/google_docs/GooglePhotosClientUtils.ts
index a13d9dcd6..671d05421 100644
--- a/src/client/apis/google_docs/GooglePhotosClientUtils.ts
+++ b/src/client/apis/google_docs/GooglePhotosClientUtils.ts
@@ -89,7 +89,7 @@ export namespace GooglePhotos {
return undefined;
}
const resolved = title ? title : (StrCast(collection.title) || `Dash Collection (${collection[Id]}`);
- const { id } = await Create.Album(resolved);
+ const { id, productUrl } = await Create.Album(resolved);
const newMediaItemResults = await Transactions.UploadImages(images, { id }, descriptionKey);
if (newMediaItemResults) {
const mediaItems = newMediaItemResults.map(item => item.mediaItem);
@@ -101,9 +101,11 @@ export namespace GooglePhotos {
const image = Doc.GetProto(images[i]);
const mediaItem = mediaItems[i];
image.googlePhotosId = mediaItem.id;
+ image.googlePhotosAlbumUrl = productUrl;
image.googlePhotosUrl = mediaItem.productUrl || mediaItem.baseUrl;
idMapping[mediaItem.id] = image;
}
+ collection.googlePhotosAlbumUrl = productUrl;
collection.googlePhotosIdMapping = idMapping;
if (tag) {
await Query.TagChildImages(collection);
diff --git a/src/client/northstar/utils/Extensions.ts b/src/client/northstar/utils/Extensions.ts
index 8254c775c..df14d4da0 100644
--- a/src/client/northstar/utils/Extensions.ts
+++ b/src/client/northstar/utils/Extensions.ts
@@ -1,12 +1,8 @@
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);
@@ -20,85 +16,6 @@ String.prototype.Truncate = function (length: number, replacement: string): Stri
return target;
};
-interface BatchContext {
- completedBatches: number;
- remainingBatches: number;
-}
-type BatchConverterSync<I, O> = (batch: I[], context: BatchContext) => O[];
-type BatchHandlerSync<I> = (batch: I[], context: BatchContext) => void;
-type BatchConverterAsync<I, O> = (batch: I[], context: BatchContext) => Promise<O[]>;
-type BatchHandlerAsync<I> = (batch: I[], context: BatchContext) => Promise<void>;
-type BatchConverter<I, O> = BatchConverterSync<I, O> | BatchConverterAsync<I, O>;
-type BatchHandler<I> = BatchHandlerSync<I> | BatchHandlerAsync<I>;
-type FixedBatcher = { batchSize: number } | { batchCount: number, mode?: Mode };
-interface ExecutorResult<A> {
- updated: A;
- makeNextBatch: boolean;
-}
-interface PredicateBatcher<I, A> {
- executor: (element: I, accumulator: A) => ExecutorResult<A>;
- initial: A;
- persistAccumulator?: boolean;
-}
-interface PredicateBatcherAsync<I, A> {
- executor: (element: I, accumulator: A) => Promise<ExecutorResult<A>>;
- initial: A;
- persistAccumulator?: boolean;
-}
-type Batcher<I, A> = FixedBatcher | PredicateBatcher<I, A>;
-type BatcherAsync<I, A> = Batcher<I, A> | PredicateBatcherAsync<I, A>;
-
-enum TimeUnit {
- Milliseconds,
- Seconds,
- Minutes
-}
-
-interface Interval {
- magnitude: number;
- unit: TimeUnit;
-}
-
-interface Array<T> {
- fixedBatch<T>(batcher: FixedBatcher): T[][];
- predicateBatch<T, A = undefined>(batcher: PredicateBatcher<T, A>): T[][];
- predicateBatchAsync<T, A = undefined>(batcher: PredicateBatcherAsync<T, A>): Promise<T[][]>;
- batch<A = undefined>(batcher: Batcher<T, A>): T[][];
- batchAsync<A = undefined>(batcher: BatcherAsync<T, A>): Promise<T[][]>;
-
- batchedForEach<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandlerSync<T>): void;
- batchedMap<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverterSync<T, O>): O[];
-
- batchedForEachAsync<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandler<T>): Promise<void>;
- batchedMapAsync<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverter<T, O>): Promise<O[]>;
-
- batchedForEachInterval<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandler<T>, interval: Interval): Promise<void>;
- batchedMapInterval<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverter<T, O>, interval: Interval): Promise<O[]>;
-
- lastElement(): T;
-}
-
-Array.prototype.fixedBatch = extensions.FixedBatch;
-Array.prototype.predicateBatch = extensions.PredicateBatch;
-Array.prototype.predicateBatchAsync = extensions.PredicateBatchAsync;
-Array.prototype.batch = extensions.Batch;
-Array.prototype.batchAsync = extensions.BatchAsync;
-
-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;
}
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
diff --git a/src/client/views/Main.tsx b/src/client/views/Main.tsx
index aa002cee9..55fa138c8 100644
--- a/src/client/views/Main.tsx
+++ b/src/client/views/Main.tsx
@@ -7,18 +7,9 @@ import { Cast } from "../../new_fields/Types";
import { Doc, DocListCastAsync } from "../../new_fields/Doc";
import { List } from "../../new_fields/List";
import { DocServer } from "../DocServer";
+const ArrayExtensions = require("../../extensions/ArrayExtensions");
-String.prototype.removeTrailingNewlines = function () {
- let sliced = this;
- while (sliced.endsWith("\n")) {
- sliced = sliced.substring(0, this.length - 1);
- }
- return sliced as string;
-};
-
-String.prototype.hasNewline = function () {
- return this.endsWith("\n");
-};
+ArrayExtensions.AssignArrayExtensions();
let swapDocs = async () => {
let oldDoc = await Cast(CurrentUserUtils.UserDocument.linkManagerDoc, Doc);
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-12-09 12:08:06 +0000