@map-colonies/mc-utils 3.1.0 → 3.3.0

package/dist/geo/tileBatcher.js

@@ -1,98 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tileBatchGenerator = void 0;
-const timeout_1 = require("../utils/timeout");
-/**
- * split collection of tile ranges to batches based on tile count
- * @param batchSize amount of tile per batch
- * @param ranges iterable collection of tile ranges
- */
-async function* tileBatchGenerator(batchSize, ranges) {
-    let targetRanges = [];
-    let requiredForFullBatch = batchSize;
-    for await (const range of ranges) {
-        const dx = range.maxX - range.minX;
-        let dy = range.maxY - range.minY;
-        if (dx === 0 || dy === 0) {
-            continue;
-        }
-        let reminderX = range.maxX;
-        while (range.minY < range.maxY) {
-            //remaining tiles in batch row row
-            if (reminderX < range.maxX) {
-                const remaining = range.maxX - reminderX;
-                if (remaining > requiredForFullBatch) {
-                    targetRanges.push({
-                        minX: reminderX,
-                        maxX: reminderX + requiredForFullBatch,
-                        minY: range.minY,
-                        maxY: range.minY + 1,
-                        zoom: range.zoom,
-                    });
-                    yield await Promise.resolve(targetRanges);
-                    reminderX += requiredForFullBatch;
-                    targetRanges = [];
-                    requiredForFullBatch = batchSize;
-                    continue;
-                }
-                else {
-                    targetRanges.push({
-                        minX: reminderX,
-                        maxX: reminderX + remaining,
-                        minY: range.minY,
-                        maxY: range.minY + 1,
-                        zoom: range.zoom,
-                    });
-                    range.minY++;
-                    reminderX += remaining;
-                    requiredForFullBatch -= remaining;
-                    dy--;
-                }
-            }
-            //add max full lines
-            const requiredLines = Math.floor(requiredForFullBatch / dx);
-            const yRange = Math.min(requiredLines, dy);
-            if (yRange > 0) {
-                targetRanges.push({
-                    minX: range.minX,
-                    maxX: range.maxX,
-                    minY: range.minY,
-                    maxY: range.minY + yRange,
-                    zoom: range.zoom,
-                });
-                range.minY += yRange;
-                dy -= yRange;
-                requiredForFullBatch -= yRange * dx;
-            }
-            //add partial lines beginning
-            if (requiredForFullBatch > 0 && range.minY < range.maxY) {
-                const endX = Math.min(range.minX + requiredForFullBatch, range.maxX);
-                targetRanges.push({
-                    minX: range.minX,
-                    maxX: endX,
-                    minY: range.minY,
-                    maxY: range.minY + 1,
-                    zoom: range.zoom,
-                });
-                requiredForFullBatch -= endX - range.minX;
-                if (endX < range.maxX) {
-                    reminderX = endX;
-                }
-                else {
-                    range.minY++;
-                }
-            }
-            if (requiredForFullBatch === 0) {
-                yield await Promise.resolve(targetRanges);
-                targetRanges = [];
-                requiredForFullBatch = batchSize;
-            }
-        }
-        await (0, timeout_1.timeout)(0); // TODO: * This is a hot fix to keep work async and handle concurrency requests while handling the task batch merging, remove this when moving to the new utils package ! *
-    }
-    if (targetRanges.length > 0) {
-        yield await Promise.resolve(targetRanges);
-    }
-}
-exports.tileBatchGenerator = tileBatchGenerator;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tileBatchGenerator = void 0;
+const timeout_1 = require("../utils/timeout");
+/**
+ * split collection of tile ranges to batches based on tile count
+ * @param batchSize amount of tile per batch
+ * @param ranges iterable collection of tile ranges
+ */
+async function* tileBatchGenerator(batchSize, ranges) {
+    let targetRanges = [];
+    let requiredForFullBatch = batchSize;
+    for await (const range of ranges) {
+        const dx = range.maxX - range.minX;
+        let dy = range.maxY - range.minY;
+        if (dx === 0 || dy === 0) {
+            continue;
+        }
+        let reminderX = range.maxX;
+        while (range.minY < range.maxY) {
+            //remaining tiles in batch row row
+            if (reminderX < range.maxX) {
+                const remaining = range.maxX - reminderX;
+                if (remaining > requiredForFullBatch) {
+                    targetRanges.push({
+                        minX: reminderX,
+                        maxX: reminderX + requiredForFullBatch,
+                        minY: range.minY,
+                        maxY: range.minY + 1,
+                        zoom: range.zoom,
+                    });
+                    yield await Promise.resolve(targetRanges);
+                    reminderX += requiredForFullBatch;
+                    targetRanges = [];
+                    requiredForFullBatch = batchSize;
+                    continue;
+                }
+                else {
+                    targetRanges.push({
+                        minX: reminderX,
+                        maxX: reminderX + remaining,
+                        minY: range.minY,
+                        maxY: range.minY + 1,
+                        zoom: range.zoom,
+                    });
+                    range.minY++;
+                    reminderX += remaining;
+                    requiredForFullBatch -= remaining;
+                    dy--;
+                }
+            }
+            //add max full lines
+            const requiredLines = Math.floor(requiredForFullBatch / dx);
+            const yRange = Math.min(requiredLines, dy);
+            if (yRange > 0) {
+                targetRanges.push({
+                    minX: range.minX,
+                    maxX: range.maxX,
+                    minY: range.minY,
+                    maxY: range.minY + yRange,
+                    zoom: range.zoom,
+                });
+                range.minY += yRange;
+                dy -= yRange;
+                requiredForFullBatch -= yRange * dx;
+            }
+            //add partial lines beginning
+            if (requiredForFullBatch > 0 && range.minY < range.maxY) {
+                const endX = Math.min(range.minX + requiredForFullBatch, range.maxX);
+                targetRanges.push({
+                    minX: range.minX,
+                    maxX: endX,
+                    minY: range.minY,
+                    maxY: range.minY + 1,
+                    zoom: range.zoom,
+                });
+                requiredForFullBatch -= endX - range.minX;
+                if (endX < range.maxX) {
+                    reminderX = endX;
+                }
+                else {
+                    range.minY++;
+                }
+            }
+            if (requiredForFullBatch === 0) {
+                yield await Promise.resolve(targetRanges);
+                targetRanges = [];
+                requiredForFullBatch = batchSize;
+            }
+        }
+        await (0, timeout_1.timeout)(0); // TODO: * This is a hot fix to keep work async and handle concurrency requests while handling the task batch merging, remove this when moving to the new utils package ! *
+    }
+    if (targetRanges.length > 0) {
+        yield await Promise.resolve(targetRanges);
+    }
+}
+exports.tileBatchGenerator = tileBatchGenerator;
 //# sourceMappingURL=tileBatcher.js.map

package/dist/geo/tileRanger.d.ts

@@ -1,47 +1,47 @@
-import { BBox2d } from '@turf/helpers/dist/js/lib/geojson';
-import { Feature, MultiPolygon, Polygon } from '@turf/turf';
-import { ITile, ITileRange } from '../models/interfaces/geo/iTile';
-/**
- * class for generating and decoding tile hashes
- */
-export declare class TileRanger {
-    /**
-     * converts tile to tile range of specified zoom level
-     * @param tile
-     * @param zoom target tile range zoom
-     * @returns
-     */
-    tileToRange(tile: ITile, zoom: number): ITileRange;
-    /**
-     * generate tile hashes
-     * @param footprint footprint to cover with generated tile hashes
-     * @param zoom max hash zoom
-     * @returns
-     */
-    encodeFootprint(footprint: Polygon | Feature<Polygon | MultiPolygon>, zoom: number, verbose?: boolean): AsyncGenerator<ITileRange>;
-    /**
-     * generate tile
-     * @param bbox bbox to cover with generated tiles
-     * @param zoom target tiles zoom level
-     */
-    generateTiles(bbox: BBox2d, zoom: number): AsyncGenerator<ITile>;
-    /**
-     * generate tile
-     * @param footprint footprint to cover with generated tiles
-     * @param zoom target tiles zoom level
-     */
-    generateTiles(footprint: Polygon | Feature<Polygon | MultiPolygon>, zoom: number): AsyncGenerator<ITile>;
-    private generateRanges;
-    /**
-     * generate tile
-     * @param tile tile to get all intersecting tiles from
-     * @param targetZoom target tiles zoom level
-     * @param intersectionTarget original zoom level and footprint to intersect
-     * @param intersectionFunction the intersection function to be called
-     */
-    private optimizeHash;
-    private generateSubTiles;
-    private readonly tileFootprintIntersection;
-    private isBbox;
-}
+import { BBox2d } from '@turf/helpers/dist/js/lib/geojson';
+import { Feature, MultiPolygon, Polygon } from '@turf/turf';
+import { ITile, ITileRange } from '../models/interfaces/geo/iTile';
+/**
+ * class for generating and decoding tile hashes
+ */
+export declare class TileRanger {
+    /**
+     * converts tile to tile range of specified zoom level
+     * @param tile
+     * @param zoom target tile range zoom
+     * @returns
+     */
+    tileToRange(tile: ITile, zoom: number): ITileRange;
+    /**
+     * generate tile hashes
+     * @param footprint footprint to cover with generated tile hashes
+     * @param zoom max hash zoom
+     * @returns
+     */
+    encodeFootprint(footprint: Polygon | Feature<Polygon | MultiPolygon>, zoom: number, verbose?: boolean): AsyncGenerator<ITileRange>;
+    /**
+     * generate tile
+     * @param bbox bbox to cover with generated tiles
+     * @param zoom target tiles zoom level
+     */
+    generateTiles(bbox: BBox2d, zoom: number): AsyncGenerator<ITile>;
+    /**
+     * generate tile
+     * @param footprint footprint to cover with generated tiles
+     * @param zoom target tiles zoom level
+     */
+    generateTiles(footprint: Polygon | Feature<Polygon | MultiPolygon>, zoom: number): AsyncGenerator<ITile>;
+    private generateRanges;
+    /**
+     * generate tile
+     * @param tile tile to get all intersecting tiles from
+     * @param targetZoom target tiles zoom level
+     * @param intersectionTarget original zoom level and footprint to intersect
+     * @param intersectionFunction the intersection function to be called
+     */
+    private optimizeHash;
+    private generateSubTiles;
+    private readonly tileFootprintIntersection;
+    private isBbox;
+}
 //# sourceMappingURL=tileRanger.d.ts.map