ropegeo-common 1.17.2 → 1.18.1

package/README.md

@@ -12,6 +12,7 @@ npm install ropegeo-common
 
 - **Models** — `import { … } from 'ropegeo-common/models'` (or `import type { … }` for symbols that are type-only in TypeScript). The package root `ropegeo-common` re-exports everything from `./models` for convenience. The subpath `ropegeo-common/classes` is kept as an alias of `./models` for older imports until dependents switch over.
 - **Helpers** — `import { … } from 'ropegeo-common/helpers'` (and `import type { … }` for helper types such as `GetS3ObjectResult`). The full barrel includes Node-only modules (S3 folder upload uses `fs`); **React Native / Metro** should use **`ropegeo-common/helpers/network`** (sources under `src/helpers/network/`, barrel `index.ts`) for the request-timeout / abort helpers only (`NETWORK_REQUEST_*`, `installNetworkRequestPolicyTimers`, `mergeParentSignalWithDeadline`, `resolveRequestTimeoutMs`, `isAbortError`, `isNetworkRequestTimeoutError`, and related types).
+- **Download** — `import { … } from 'ropegeo-common/download'` for job orchestration (`DownloadJobQueue`, `DownloadJob`, tasks, dependencies). Not re-exported from `ropegeo-common/models`. Mobile implements `DownloadPlatformHarness` in its own `lib/download/` folder.
 
 Helper tables use columns **Name**, **Description**, **Import**. Model tables add **Base class** after **Name** (`N/A` for enums, TypeScript-only type aliases, constants, registration functions, and classes without an exported superclass; otherwise the direct superclass).
 
@@ -261,15 +262,45 @@ Abstract classes live under `minimap/abstract/`, concrete under `minimap/concret
 | `OfflineMiniMap` | N/A | Interface: `fetchType: "offline"` and `miniMapType`. | `import type { OfflineMiniMap } from 'ropegeo-common/models'` |
 | `MiniMap` | N/A | Abstract base for minimaps; `fromResult` parses API wire types only. | `import { MiniMap } from 'ropegeo-common/models'` |
 | `RegionMiniMap` | `MiniMap` | Abstract region minimap (`miniMapType: region`); online/offline concrete subclasses. | `import { RegionMiniMap } from 'ropegeo-common/models'` |
-| `OnlineRegionMiniMap` | `RegionMiniMap` | API region routes (`routesParams`, `bounds` or null, `fetchType: "online"`). | `import { OnlineRegionMiniMap } from 'ropegeo-common/models'` |
+| `OnlineRegionMiniMap` | `RegionMiniMap` | API region routes (`routesParams`, `bounds` or null, `routeCount`, `totalBytes`, `fetchType: "online"`). | `import { OnlineRegionMiniMap } from 'ropegeo-common/models'` |
 | `OfflineRegionMiniMap` | `RegionMiniMap` | Bundled region routes GeoJSON path (`downloadedGeojson`, `fetchType: "offline"`). | `import { OfflineRegionMiniMap } from 'ropegeo-common/models'` |
 | `PageMiniMap` | `MiniMap` | Abstract page minimap (`miniMapType: page`); MVT `polyLineLayerId` / `pointLayerId`, tile templates, optional `legend`. | `import { PageMiniMap } from 'ropegeo-common/models'` |
-| `OnlinePageMiniMap` | `PageMiniMap` | API page tiles (`onlineTilesTemplate`, `fetchType: "online"`). | `import { OnlinePageMiniMap } from 'ropegeo-common/models'` |
+| `OnlinePageMiniMap` | `PageMiniMap` | API page tiles (`onlineTilesTemplate`, `tileCount`, `tileTotalBytes`, `fetchType: "online"`). | `import { OnlinePageMiniMap } from 'ropegeo-common/models'` |
 | `OfflinePageMiniMap` | `PageMiniMap` | Local page tiles (`offlineTilesTemplate`, `fetchType: "offline"`). | `import { OfflinePageMiniMap } from 'ropegeo-common/models'` |
 | `CenteredRegionMiniMap` | `MiniMap` | Abstract centered-route minimap (`miniMapType: centeredRegion`). | `import { CenteredRegionMiniMap } from 'ropegeo-common/models'` |
-| `OnlineCenteredRegionMiniMap` | `CenteredRegionMiniMap` | API centered-route fallback (`routesParams`, `fetchType: "online"`). | `import { OnlineCenteredRegionMiniMap } from 'ropegeo-common/models'` |
+| `OnlineCenteredRegionMiniMap` | `CenteredRegionMiniMap` | API centered-route fallback (`routesParams`, `routeCount`, `totalBytes`, `fetchType: "online"`). | `import { OnlineCenteredRegionMiniMap } from 'ropegeo-common/models'` |
 | `OfflineCenteredRegionMiniMap` | `CenteredRegionMiniMap` | Persisted local centered-route geojson (`downloadedGeojson`, `fetchType: "offline"`). | `import { OfflineCenteredRegionMiniMap } from 'ropegeo-common/models'` |
 
+### Download orchestration (`src/download/`)
+
+Import from **`ropegeo-common/download`**. Platform I/O (Expo FileSystem, Mapbox, AsyncStorage) is implemented by Mobile via `DownloadPlatformHarness`; Common owns job planning and task logic only. List/page JSON fetches inside download tasks use `downloadHttpRequest` (global `fetch` only), not `httpRequest` (Lambda proxy / undici).
+
+| Name | Description | Import |
+| --- | --- | --- |
+| `DownloadJobQueue` | FIFO queue: enqueue jobs, foreground/background ticks, persist/restore. | `import { DownloadJobQueue } from 'ropegeo-common/download'` |
+| `DownloadJob` | Single page download: mutable `phases`, `taskDependencies`, `runTick`, `appendPhases`. | `import { DownloadJob } from 'ropegeo-common/download'` |
+| `DownloadPhase` | Parallel task group with shared title and progress. | `import { DownloadPhase } from 'ropegeo-common/download'` |
+| `DownloadTask` | Abstract unit of work per tick; concrete tasks in `src/download/tasks/`. | `import { DownloadTask } from 'ropegeo-common/download'` |
+| `DownloadPlatformHarness` | Platform adapter type (file I/O, Mapbox pack, job store). | `import type { DownloadPlatformHarness } from 'ropegeo-common/download'` |
+| `DownloadJobConfig` | Job config: `savedAt`, `mapboxStyleUrl`, `webScraperBaseUrl`, optional `onProgress`. | `import type { DownloadJobConfig } from 'ropegeo-common/download'` |
+| `DownloadJobUISnapshot` | Runtime UI progress (phase title, step/total, percent). | `import type { DownloadJobUISnapshot } from 'ropegeo-common/download'` |
+| `DownloadJobQueueStoredState` | Persisted queue envelope (`queueOrder`, `jobs`). | `import type { DownloadJobQueueStoredState } from 'ropegeo-common/download'` |
+| `DownloadJobStoredState` | Persisted single in-flight job. | `import type { DownloadJobStoredState } from 'ropegeo-common/download'` |
+| `DownloadDependencyKeys` | String keys for task dependency map entries. | `import { DownloadDependencyKeys } from 'ropegeo-common/download'` |
+| `planDownloadPhases` | Builds content phases for a full `OnlineRopewikiPageView` (explore path). | `import { planDownloadPhases } from 'ropegeo-common/download'` |
+| `seedConsumerDependencies` | Seeds dependency objects for tasks in a phase plan. | `import { seedConsumerDependencies } from 'ropegeo-common/download'` |
+| `DeleteStoredPageTask` | Phase 1: delete existing offline bundle for the page. | `import { DeleteStoredPageTask } from 'ropegeo-common/download'` |
+| `FetchPageJsonTask` | Preview path: fetch page JSON and append content phases. | `import { FetchPageJsonTask } from 'ropegeo-common/download'` |
+| `FetchImageFilesTask` | Download beta/banner image files. | `import { FetchImageFilesTask } from 'ropegeo-common/download'` |
+| `FetchMapboxPackTask` | Download Mapbox offline pack for page minimap bounds. | `import { FetchMapboxPackTask } from 'ropegeo-common/download'` |
+| `FetchRopeGeoTileListTask` | Parallel paginated tile key list fetches. | `import { FetchRopeGeoTileListTask } from 'ropegeo-common/download'` |
+| `FetchRopeGeoTileFilesTask` | Download `.pbf` tile files. | `import { FetchRopeGeoTileFilesTask } from 'ropegeo-common/download'` |
+| `FetchRegionRouteListTask` | Parallel paginated region route list fetches. | `import { FetchRegionRouteListTask } from 'ropegeo-common/download'` |
+| `SaveOfflinePageTask` | Persist offline page view, images, and minimap data. | `import { SaveOfflinePageTask } from 'ropegeo-common/download'` |
+| `InvalidDownloadJobStoredStateError` | Thrown when persisted job state fails validation. | `import { InvalidDownloadJobStoredStateError } from 'ropegeo-common/download'` |
+| `reconcilePendingFileTransfer` | Reconcile native file transfer state with expected progress. | `import { reconcilePendingFileTransfer } from 'ropegeo-common/download'` |
+| `enqueuePendingFileTransfer` | Enqueue a native background file download. | `import { enqueuePendingFileTransfer } from 'ropegeo-common/download'` |
+
 ### Minimap legend (`src/models/minimap/legend/`)
 
 Legend entries for page minimaps are keyed objects (`legend` on `PageMiniMap`); each value is validated by `featureType` like `MiniMap`.

package/dist/download/dependencies/downloadDependencyKeys.d.ts

@@ -0,0 +1,13 @@
+export declare const DownloadDependencyKeys: {
+    readonly FetchPageJson: "fetchPageJson";
+    readonly FetchImageFiles: "fetchImageFiles";
+    readonly FetchMapboxPack: "fetchMapboxPack";
+    readonly FetchRopeGeoTileList: "fetchRopeGeoTileList";
+    readonly FetchRopeGeoTileFiles: "fetchRopeGeoTileFiles";
+    readonly FetchRegionRouteList: "fetchRegionRouteList";
+    readonly SaveOfflinePageView: "saveOfflinePageView";
+    readonly SaveOfflinePageImages: "saveOfflinePageImages";
+    readonly SaveOfflinePageMiniMap: "saveOfflinePageMiniMap";
+};
+export type DownloadDependencyKey = (typeof DownloadDependencyKeys)[keyof typeof DownloadDependencyKeys];
+//# sourceMappingURL=downloadDependencyKeys.d.ts.map

package/dist/download/dependencies/downloadDependencyKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloadDependencyKeys.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/downloadDependencyKeys.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;CAUzB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC7B,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/download/dependencies/downloadDependencyKeys.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadDependencyKeys = void 0;
+exports.DownloadDependencyKeys = {
+    FetchPageJson: 'fetchPageJson',
+    FetchImageFiles: 'fetchImageFiles',
+    FetchMapboxPack: 'fetchMapboxPack',
+    FetchRopeGeoTileList: 'fetchRopeGeoTileList',
+    FetchRopeGeoTileFiles: 'fetchRopeGeoTileFiles',
+    FetchRegionRouteList: 'fetchRegionRouteList',
+    SaveOfflinePageView: 'saveOfflinePageView',
+    SaveOfflinePageImages: 'saveOfflinePageImages',
+    SaveOfflinePageMiniMap: 'saveOfflinePageMiniMap',
+};

package/dist/download/dependencies/fetchImageFilesTaskDependency.d.ts

@@ -0,0 +1,9 @@
+import type { DownloadTaskDependency, FetchImageFilesSlot } from '../types';
+export declare class FetchImageFilesTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchImageFiles";
+    readonly slots: FetchImageFilesSlot[];
+    constructor(slots: FetchImageFilesSlot[]);
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchImageFilesTaskDependency;
+}
+//# sourceMappingURL=fetchImageFilesTaskDependency.d.ts.map

package/dist/download/dependencies/fetchImageFilesTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchImageFilesTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchImageFilesTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE5E,qBAAa,6BAA8B,YAAW,sBAAsB;IACxE,QAAQ,CAAC,cAAc,EAAG,iBAAiB,CAAU;IACrD,QAAQ,CAAC,KAAK,EAAE,mBAAmB,EAAE,CAAC;gBAE1B,KAAK,EAAE,mBAAmB,EAAE;IAIxC,aAAa,IAAI,OAAO;IAOxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,6BAA6B;CAqCtE"}

package/dist/download/dependencies/fetchImageFilesTaskDependency.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchImageFilesTaskDependency = void 0;
+class FetchImageFilesTaskDependency {
+    constructor(slots) {
+        this.dependencyKind = 'fetchImageFiles';
+        this.slots = slots;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            slots: this.slots,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchImageFilesTaskDependency must be an object');
+        }
+        const value = raw;
+        if (!Array.isArray(value.slots)) {
+            throw new Error('FetchImageFilesTaskDependency.slots must be an array');
+        }
+        const slots = value.slots.map((entry, index) => {
+            if (entry == null || typeof entry !== 'object') {
+                throw new Error(`FetchImageFilesTaskDependency.slots[${index}] must be an object`);
+            }
+            const slot = entry;
+            if (typeof slot.imageId !== 'string' || slot.imageId.length === 0) {
+                throw new Error(`FetchImageFilesTaskDependency.slots[${index}].imageId invalid`);
+            }
+            const rawVersions = slot.versions;
+            if (rawVersions == null || typeof rawVersions !== 'object') {
+                throw new Error(`FetchImageFilesTaskDependency.slots[${index}].versions invalid`);
+            }
+            const versionsRecord = rawVersions;
+            const versions = {};
+            for (const key of ['preview', 'banner', 'full']) {
+                const item = versionsRecord[key];
+                if (item !== undefined && item !== null && typeof item !== 'string') {
+                    throw new Error(`FetchImageFilesTaskDependency.slots[${index}].versions.${key} invalid`);
+                }
+                if (item !== undefined) {
+                    versions[key] = item;
+                }
+            }
+            return { imageId: slot.imageId, versions };
+        });
+        return new FetchImageFilesTaskDependency(slots);
+    }
+}
+exports.FetchImageFilesTaskDependency = FetchImageFilesTaskDependency;

package/dist/download/dependencies/fetchMapboxPackTaskDependency.d.ts

@@ -0,0 +1,10 @@
+import { Bounds } from '../../models/minimap/bounds';
+import type { DownloadTaskDependency } from '../types';
+export declare class FetchMapboxPackTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchMapboxPack";
+    readonly bounds: Bounds;
+    constructor(bounds: Bounds);
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchMapboxPackTaskDependency;
+}
+//# sourceMappingURL=fetchMapboxPackTaskDependency.d.ts.map

package/dist/download/dependencies/fetchMapboxPackTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchMapboxPackTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchMapboxPackTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,6BAA8B,YAAW,sBAAsB;IACxE,QAAQ,CAAC,cAAc,EAAG,iBAAiB,CAAU;IACrD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;IAI1B,aAAa,IAAI,OAAO;IAOxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,6BAA6B;CAOtE"}

package/dist/download/dependencies/fetchMapboxPackTaskDependency.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchMapboxPackTaskDependency = void 0;
+const bounds_1 = require("../../models/minimap/bounds");
+class FetchMapboxPackTaskDependency {
+    constructor(bounds) {
+        this.dependencyKind = 'fetchMapboxPack';
+        this.bounds = bounds;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            bounds: this.bounds,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchMapboxPackTaskDependency must be an object');
+        }
+        const value = raw;
+        return new FetchMapboxPackTaskDependency(bounds_1.Bounds.fromResult(value.bounds));
+    }
+}
+exports.FetchMapboxPackTaskDependency = FetchMapboxPackTaskDependency;

package/dist/download/dependencies/fetchPageJsonTaskDependency.d.ts

@@ -0,0 +1,18 @@
+import { PageDataSource } from '../../models/pageDataSource';
+import { PageViewType } from '../../models/pageViews/pageViewType';
+import type { DownloadJobConfig } from '../types';
+import type { DownloadTaskDependency } from '../types';
+export declare class FetchPageJsonTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchPageJson";
+    readonly pageId: string;
+    readonly pageViewType: PageViewType;
+    readonly pageUrl: string;
+    constructor(pageId: string, pageViewType: PageViewType, pageUrl: string);
+    static fromPreview(preview: {
+        id: string;
+        source: PageDataSource;
+    }, config: DownloadJobConfig): FetchPageJsonTaskDependency;
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchPageJsonTaskDependency;
+}
+//# sourceMappingURL=fetchPageJsonTaskDependency.d.ts.map

package/dist/download/dependencies/fetchPageJsonTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchPageJsonTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchPageJsonTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,2BAA4B,YAAW,sBAAsB;IACtE,QAAQ,CAAC,cAAc,EAAG,eAAe,CAAU;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM;IAMvE,MAAM,CAAC,WAAW,CACd,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,cAAc,CAAA;KAAE,EAC/C,MAAM,EAAE,iBAAiB,GAC1B,2BAA2B;IAe9B,aAAa,IAAI,OAAO;IASxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,2BAA2B;CAkBpE"}

package/dist/download/dependencies/fetchPageJsonTaskDependency.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchPageJsonTaskDependency = void 0;
+const pageDataSource_1 = require("../../models/pageDataSource");
+const pageViewType_1 = require("../../models/pageViews/pageViewType");
+class FetchPageJsonTaskDependency {
+    constructor(pageId, pageViewType, pageUrl) {
+        this.dependencyKind = 'fetchPageJson';
+        this.pageId = pageId;
+        this.pageViewType = pageViewType;
+        this.pageUrl = pageUrl;
+    }
+    static fromPreview(preview, config) {
+        const pageViewType = preview.source === pageDataSource_1.PageDataSource.Ropewiki
+            ? pageViewType_1.PageViewType.Ropewiki
+            : null;
+        if (pageViewType == null) {
+            throw new Error(`Unsupported preview source: ${String(preview.source)}`);
+        }
+        const pageUrl = new URL(`/${encodeURIComponent(pageViewType)}/page/${encodeURIComponent(preview.id)}`, config.webScraperBaseUrl).toString();
+        return new FetchPageJsonTaskDependency(preview.id, pageViewType, pageUrl);
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            pageId: this.pageId,
+            pageViewType: this.pageViewType,
+            pageUrl: this.pageUrl,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchPageJsonTaskDependency must be an object');
+        }
+        const value = raw;
+        if (typeof value.pageId !== 'string' || value.pageId.length === 0) {
+            throw new Error('FetchPageJsonTaskDependency.pageId must be a non-empty string');
+        }
+        if (value.pageViewType !== pageViewType_1.PageViewType.Ropewiki) {
+            throw new Error('FetchPageJsonTaskDependency.pageViewType is invalid');
+        }
+        if (typeof value.pageUrl !== 'string' || value.pageUrl.length === 0) {
+            throw new Error('FetchPageJsonTaskDependency.pageUrl must be a non-empty string');
+        }
+        return new FetchPageJsonTaskDependency(value.pageId, value.pageViewType, value.pageUrl);
+    }
+}
+exports.FetchPageJsonTaskDependency = FetchPageJsonTaskDependency;

package/dist/download/dependencies/fetchRegionRouteListTaskDependency.d.ts

@@ -0,0 +1,23 @@
+import { RoutesParams } from '../../models/api/params/routesParams';
+import type { DownloadTaskDependency } from '../types';
+export declare class FetchRegionRouteListTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchRegionRouteList";
+    readonly routesParams: RoutesParams;
+    readonly routeCount: number;
+    readonly totalBytes: number;
+    readonly regionId: string;
+    readonly centeredRouteId: string | null;
+    readonly miniMapTitle: string;
+    constructor(args: {
+        routesParams: RoutesParams;
+        routeCount: number;
+        totalBytes: number;
+        regionId: string;
+        centeredRouteId: string | null;
+        miniMapTitle: string;
+    });
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchRegionRouteListTaskDependency;
+    private static toNonNegativeInt;
+}
+//# sourceMappingURL=fetchRegionRouteListTaskDependency.d.ts.map

package/dist/download/dependencies/fetchRegionRouteListTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchRegionRouteListTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchRegionRouteListTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,sCAAsC,CAAC;AACpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,kCAAmC,YAAW,sBAAsB;IAC7E,QAAQ,CAAC,cAAc,EAAG,sBAAsB,CAAU;IAC1D,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAElB,IAAI,EAAE;QACd,YAAY,EAAE,YAAY,CAAC;QAC3B,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;KACxB;IASD,aAAa,IAAI,OAAO;IAYxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,kCAAkC;IA2BxE,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAMlC"}

package/dist/download/dependencies/fetchRegionRouteListTaskDependency.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchRegionRouteListTaskDependency = void 0;
+const routesParams_1 = require("../../models/api/params/routesParams");
+class FetchRegionRouteListTaskDependency {
+    constructor(args) {
+        this.dependencyKind = 'fetchRegionRouteList';
+        this.routesParams = args.routesParams;
+        this.routeCount = args.routeCount;
+        this.totalBytes = args.totalBytes;
+        this.regionId = args.regionId;
+        this.centeredRouteId = args.centeredRouteId;
+        this.miniMapTitle = args.miniMapTitle;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            routesParams: this.routesParams,
+            routeCount: this.routeCount,
+            totalBytes: this.totalBytes,
+            regionId: this.regionId,
+            centeredRouteId: this.centeredRouteId,
+            miniMapTitle: this.miniMapTitle,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchRegionRouteListTaskDependency must be an object');
+        }
+        const value = raw;
+        if (typeof value.regionId !== 'string' || value.regionId.length === 0) {
+            throw new Error('FetchRegionRouteListTaskDependency.regionId must be a non-empty string');
+        }
+        if (value.centeredRouteId !== null && value.centeredRouteId !== undefined && typeof value.centeredRouteId !== 'string') {
+            throw new Error('FetchRegionRouteListTaskDependency.centeredRouteId invalid');
+        }
+        if (typeof value.miniMapTitle !== 'string' || value.miniMapTitle.length === 0) {
+            throw new Error('FetchRegionRouteListTaskDependency.miniMapTitle must be a non-empty string');
+        }
+        const routeCount = FetchRegionRouteListTaskDependency.toNonNegativeInt(value.routeCount, 'routeCount');
+        const totalBytes = FetchRegionRouteListTaskDependency.toNonNegativeInt(value.totalBytes, 'totalBytes');
+        return new FetchRegionRouteListTaskDependency({
+            routesParams: routesParams_1.RoutesParams.fromResult(value.routesParams, true),
+            routeCount,
+            totalBytes,
+            regionId: value.regionId,
+            centeredRouteId: typeof value.centeredRouteId === 'string' ? value.centeredRouteId : null,
+            miniMapTitle: value.miniMapTitle,
+        });
+    }
+    static toNonNegativeInt(value, field) {
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+            throw new Error(`FetchRegionRouteListTaskDependency.${field} must be a non-negative integer`);
+        }
+        return value;
+    }
+}
+exports.FetchRegionRouteListTaskDependency = FetchRegionRouteListTaskDependency;

package/dist/download/dependencies/fetchRopeGeoTileFilesTaskDependency.d.ts

@@ -0,0 +1,17 @@
+import type { DownloadTaskDependency } from '../types';
+export declare class FetchRopeGeoTileFilesTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchRopeGeoTileFiles";
+    readonly mapDataId: string;
+    readonly tileUrls: string[];
+    readonly tileTotalBytes: number;
+    readonly pageMiniMapWire: Record<string, unknown>;
+    constructor(args: {
+        mapDataId: string;
+        tileUrls: string[];
+        tileTotalBytes: number;
+        pageMiniMapWire: Record<string, unknown>;
+    });
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchRopeGeoTileFilesTaskDependency;
+}
+//# sourceMappingURL=fetchRopeGeoTileFilesTaskDependency.d.ts.map

package/dist/download/dependencies/fetchRopeGeoTileFilesTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchRopeGeoTileFilesTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchRopeGeoTileFilesTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,mCAAoC,YAAW,sBAAsB;IAC9E,QAAQ,CAAC,cAAc,EAAG,uBAAuB,CAAU;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtC,IAAI,EAAE;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC5C;IAOD,aAAa,IAAI,OAAO;IAUxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,mCAAmC;CA4B5E"}

package/dist/download/dependencies/fetchRopeGeoTileFilesTaskDependency.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchRopeGeoTileFilesTaskDependency = void 0;
+class FetchRopeGeoTileFilesTaskDependency {
+    constructor(args) {
+        this.dependencyKind = 'fetchRopeGeoTileFiles';
+        this.mapDataId = args.mapDataId;
+        this.tileUrls = args.tileUrls;
+        this.tileTotalBytes = args.tileTotalBytes;
+        this.pageMiniMapWire = args.pageMiniMapWire;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            mapDataId: this.mapDataId,
+            tileUrls: this.tileUrls,
+            tileTotalBytes: this.tileTotalBytes,
+            pageMiniMapWire: this.pageMiniMapWire,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchRopeGeoTileFilesTaskDependency must be an object');
+        }
+        const value = raw;
+        if (typeof value.mapDataId !== 'string' || value.mapDataId.length === 0) {
+            throw new Error('FetchRopeGeoTileFilesTaskDependency.mapDataId must be a non-empty string');
+        }
+        if (!Array.isArray(value.tileUrls) || value.tileUrls.some((url) => typeof url !== 'string')) {
+            throw new Error('FetchRopeGeoTileFilesTaskDependency.tileUrls must be string[]');
+        }
+        if (typeof value.tileTotalBytes !== 'number' ||
+            !Number.isInteger(value.tileTotalBytes) ||
+            value.tileTotalBytes < 0) {
+            throw new Error('FetchRopeGeoTileFilesTaskDependency.tileTotalBytes must be a non-negative integer');
+        }
+        if (value.pageMiniMapWire == null || typeof value.pageMiniMapWire !== 'object') {
+            throw new Error('FetchRopeGeoTileFilesTaskDependency.pageMiniMapWire must be an object');
+        }
+        return new FetchRopeGeoTileFilesTaskDependency({
+            mapDataId: value.mapDataId,
+            tileUrls: value.tileUrls,
+            tileTotalBytes: value.tileTotalBytes,
+            pageMiniMapWire: value.pageMiniMapWire,
+        });
+    }
+}
+exports.FetchRopeGeoTileFilesTaskDependency = FetchRopeGeoTileFilesTaskDependency;

package/dist/download/dependencies/fetchRopeGeoTileListTaskDependency.d.ts

@@ -0,0 +1,20 @@
+import type { DownloadTaskDependency } from '../types';
+export declare class FetchRopeGeoTileListTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "fetchRopeGeoTileList";
+    readonly mapDataId: string;
+    readonly tileCount: number;
+    readonly tileTotalBytes: number;
+    readonly listPageLimit: number;
+    readonly pageMiniMapWire: Record<string, unknown>;
+    constructor(args: {
+        mapDataId: string;
+        tileCount: number;
+        tileTotalBytes: number;
+        listPageLimit: number;
+        pageMiniMapWire: Record<string, unknown>;
+    });
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): FetchRopeGeoTileListTaskDependency;
+    private static toNonNegativeInt;
+}
+//# sourceMappingURL=fetchRopeGeoTileListTaskDependency.d.ts.map

package/dist/download/dependencies/fetchRopeGeoTileListTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchRopeGeoTileListTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/fetchRopeGeoTileListTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,kCAAmC,YAAW,sBAAsB;IAC7E,QAAQ,CAAC,cAAc,EAAG,sBAAsB,CAAU;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtC,IAAI,EAAE;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC5C;IAQD,aAAa,IAAI,OAAO;IAWxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,kCAAkC;IA6BxE,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAMlC"}

package/dist/download/dependencies/fetchRopeGeoTileListTaskDependency.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchRopeGeoTileListTaskDependency = void 0;
+class FetchRopeGeoTileListTaskDependency {
+    constructor(args) {
+        this.dependencyKind = 'fetchRopeGeoTileList';
+        this.mapDataId = args.mapDataId;
+        this.tileCount = args.tileCount;
+        this.tileTotalBytes = args.tileTotalBytes;
+        this.listPageLimit = args.listPageLimit;
+        this.pageMiniMapWire = args.pageMiniMapWire;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            mapDataId: this.mapDataId,
+            tileCount: this.tileCount,
+            tileTotalBytes: this.tileTotalBytes,
+            listPageLimit: this.listPageLimit,
+            pageMiniMapWire: this.pageMiniMapWire,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('FetchRopeGeoTileListTaskDependency must be an object');
+        }
+        const value = raw;
+        if (typeof value.mapDataId !== 'string' || value.mapDataId.length === 0) {
+            throw new Error('FetchRopeGeoTileListTaskDependency.mapDataId must be a non-empty string');
+        }
+        const tileCount = FetchRopeGeoTileListTaskDependency.toNonNegativeInt(value.tileCount, 'tileCount');
+        const tileTotalBytes = FetchRopeGeoTileListTaskDependency.toNonNegativeInt(value.tileTotalBytes, 'tileTotalBytes');
+        const listPageLimit = FetchRopeGeoTileListTaskDependency.toNonNegativeInt(value.listPageLimit, 'listPageLimit');
+        if (value.pageMiniMapWire == null || typeof value.pageMiniMapWire !== 'object') {
+            throw new Error('FetchRopeGeoTileListTaskDependency.pageMiniMapWire must be an object');
+        }
+        return new FetchRopeGeoTileListTaskDependency({
+            mapDataId: value.mapDataId,
+            tileCount,
+            tileTotalBytes,
+            listPageLimit,
+            pageMiniMapWire: value.pageMiniMapWire,
+        });
+    }
+    static toNonNegativeInt(value, field) {
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+            throw new Error(`FetchRopeGeoTileListTaskDependency.${field} must be a non-negative integer`);
+        }
+        return value;
+    }
+}
+exports.FetchRopeGeoTileListTaskDependency = FetchRopeGeoTileListTaskDependency;

package/dist/download/dependencies/saveOfflinePageImagesTaskDependency.d.ts

@@ -0,0 +1,9 @@
+import type { DownloadedImageVersions, DownloadTaskDependency } from '../types';
+export declare class SaveOfflinePageImagesTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "saveOfflinePageImages";
+    readonly downloadedImages: Record<string, DownloadedImageVersions>;
+    constructor(downloadedImages: Record<string, DownloadedImageVersions>);
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): SaveOfflinePageImagesTaskDependency;
+}
+//# sourceMappingURL=saveOfflinePageImagesTaskDependency.d.ts.map

package/dist/download/dependencies/saveOfflinePageImagesTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveOfflinePageImagesTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/saveOfflinePageImagesTaskDependency.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEhF,qBAAa,mCAAoC,YAAW,sBAAsB;IAC9E,QAAQ,CAAC,cAAc,EAAG,uBAAuB,CAAU;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;gBAEvD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC;IAIrE,aAAa,IAAI,OAAO;IAOxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,mCAAmC;CA8B5E"}

package/dist/download/dependencies/saveOfflinePageImagesTaskDependency.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveOfflinePageImagesTaskDependency = void 0;
+const imageVersions_1 = require("../../models/mobile/imageVersions");
+class SaveOfflinePageImagesTaskDependency {
+    constructor(downloadedImages) {
+        this.dependencyKind = 'saveOfflinePageImages';
+        this.downloadedImages = downloadedImages;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            downloadedImages: this.downloadedImages,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('SaveOfflinePageImagesTaskDependency must be an object');
+        }
+        const value = raw;
+        if (value.downloadedImages == null || typeof value.downloadedImages !== 'object') {
+            throw new Error('SaveOfflinePageImagesTaskDependency.downloadedImages must be an object');
+        }
+        const downloadedImages = {};
+        for (const [imageId, versionsRaw] of Object.entries(value.downloadedImages)) {
+            if (versionsRaw == null || typeof versionsRaw !== 'object') {
+                throw new Error(`SaveOfflinePageImagesTaskDependency.downloadedImages.${imageId} invalid`);
+            }
+            const versionsRecord = versionsRaw;
+            const versions = {};
+            for (const key of Object.values(imageVersions_1.ImageVersion)) {
+                const maybe = versionsRecord[key];
+                if (maybe !== undefined && maybe !== null && typeof maybe !== 'string') {
+                    throw new Error(`SaveOfflinePageImagesTaskDependency.downloadedImages.${imageId}.${key} invalid`);
+                }
+                if (maybe !== undefined) {
+                    versions[key] = maybe;
+                }
+            }
+            downloadedImages[imageId] = versions;
+        }
+        return new SaveOfflinePageImagesTaskDependency(downloadedImages);
+    }
+}
+exports.SaveOfflinePageImagesTaskDependency = SaveOfflinePageImagesTaskDependency;

package/dist/download/dependencies/saveOfflinePageMiniMapTaskDependency.d.ts

@@ -0,0 +1,9 @@
+import type { DownloadTaskDependency } from '../types';
+export declare class SaveOfflinePageMiniMapTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "saveOfflinePageMiniMap";
+    readonly offlineMiniMapWire: Record<string, unknown>;
+    constructor(offlineMiniMapWire: Record<string, unknown>);
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): SaveOfflinePageMiniMapTaskDependency;
+}
+//# sourceMappingURL=saveOfflinePageMiniMapTaskDependency.d.ts.map

package/dist/download/dependencies/saveOfflinePageMiniMapTaskDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"saveOfflinePageMiniMapTaskDependency.d.ts","sourceRoot":"","sources":["../../../src/download/dependencies/saveOfflinePageMiniMapTaskDependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAEvD,qBAAa,oCAAqC,YAAW,sBAAsB;IAC/E,QAAQ,CAAC,cAAc,EAAG,wBAAwB,CAAU;IAC5D,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEzC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAIvD,aAAa,IAAI,OAAO;IAOxB,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,oCAAoC;CAY7E"}

package/dist/download/dependencies/saveOfflinePageMiniMapTaskDependency.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveOfflinePageMiniMapTaskDependency = void 0;
+class SaveOfflinePageMiniMapTaskDependency {
+    constructor(offlineMiniMapWire) {
+        this.dependencyKind = 'saveOfflinePageMiniMap';
+        this.offlineMiniMapWire = offlineMiniMapWire;
+    }
+    toStoredState() {
+        return {
+            dependencyKind: this.dependencyKind,
+            offlineMiniMapWire: this.offlineMiniMapWire,
+        };
+    }
+    static fromStoredState(raw) {
+        if (raw == null || typeof raw !== 'object') {
+            throw new Error('SaveOfflinePageMiniMapTaskDependency must be an object');
+        }
+        const value = raw;
+        if (value.offlineMiniMapWire == null || typeof value.offlineMiniMapWire !== 'object') {
+            throw new Error('SaveOfflinePageMiniMapTaskDependency.offlineMiniMapWire must be an object');
+        }
+        return new SaveOfflinePageMiniMapTaskDependency(value.offlineMiniMapWire);
+    }
+}
+exports.SaveOfflinePageMiniMapTaskDependency = SaveOfflinePageMiniMapTaskDependency;

package/dist/download/dependencies/saveOfflinePageViewTaskDependency.d.ts

@@ -0,0 +1,12 @@
+import type { DownloadTaskDependency } from '../types';
+export declare class SaveOfflinePageViewTaskDependency implements DownloadTaskDependency {
+    readonly dependencyKind: "saveOfflinePageView";
+    readonly onlineViewWire: Record<string, unknown>;
+    constructor(onlineViewWire: Record<string, unknown>);
+    static fromView(view: {
+        toPlain(): Record<string, unknown>;
+    }): SaveOfflinePageViewTaskDependency;
+    toStoredState(): unknown;
+    static fromStoredState(raw: unknown): SaveOfflinePageViewTaskDependency;
+}
+//# sourceMappingURL=saveOfflinePageViewTaskDependency.d.ts.map