Variable CacheCalculatorConst

Type Declaration

• defaults: {
      maxTilesPerZoom: number;
      maxTotalTiles: number;
      avgTileSize: number;
      boundsMargin: number;
      webMercatorMaxLat: number;
  }

• getTileCoordsForBounds: function

  • getTileCoordsForBounds(
        bounds: Bounds | null | undefined,
        zoom: number,
        config?: TileConfig,
    ): TileCoord[]

    Parameters

    • bounds: Bounds | null | undefined
    • zoom: number
    • config: TileConfig = {}

    Returns TileCoord[]

• latLngToTile: function

  • latLngToTile(lat: number, lng: number, zoom: number): TileCoord

    Convert lat/lng to tile coordinates (Web Mercator projection)

    Delegates to tile-math.js. defaults.webMercatorMaxLat is forwarded explicitly so that mutating it on this object stays effective.

    Parameters

    • lat: number

      Latitude

    • lng: number

      Longitude

    • zoom: number

      Zoom level

    Returns TileCoord

    Tile coordinates

• buildTileUrl: function

  • buildTileUrl(template: string, x: number, y: number, zoom: number): string

    Build tile URL from template

    Parameters

    • template: string

      URL template with {x}, {y}, {z} placeholders

    • x: number

      Tile X coordinate

    • y: number

      Tile Y coordinate

    • zoom: number

      Zoom level

    Returns string

    Complete tile URL

• calculateProfileBounds: function

  • calculateProfileBounds(
        _profile: unknown,
        resources: ResourceWithSize[],
    ): Promise<Bounds | null>

    Calculate bounds from layer geometries

    ⚠️ resource.url is not trusted: the enumerated resource list is fed, among others, by StyleResolver from a REMOTE TileJSON, so a hostile document can put an arbitrary URL in it. Each entry is scheme-guarded before it is fetched; a refused one is skipped like any unreadable layer, so one poisoned entry cannot blind the whole bounds computation (CAPACITÉS B.10).

    Parameters

    • _profile: unknown

      Unused. Kept in the signature so the four calculate* members share one call shape; bounds come from resources alone.

    • resources: ResourceWithSize[]

      The enumerated resources; only type: "layer" entries contribute.

    Returns Promise<Bounds | null>

    Bounds { north, south, east, west }, or null if no layer was readable.

• extractCoordinates: function

  • extractCoordinates(
        geometry: {
            type?: string;
            coordinates?: unknown[];
            geometries?: unknown[];
        },
    ): number[][]

    Extract all coordinates from a geometry

    Parameters

    • geometry: { type?: string; coordinates?: unknown[]; geometries?: unknown[] }

      GeoJSON geometry object

    Returns number[][]

    Array of [lng, lat] coordinates

• expandBounds: function

  • expandBounds(bounds: Bounds | null, coords: number[][]): Bounds | null

    Expand bounds with new coordinates

    Parameters

    • bounds: Bounds | null

      Current bounds or null

    • coords: number[][]

      Array of [lng, lat] coordinates

    Returns Bounds | null

    Updated bounds { north, south, east, west }

• estimateTileSize: function

  • estimateTileSize(tileCount: number, avgSize?: number): number

    Estimate total size of tiles

    Parameters

    • tileCount: number

      Number of tiles

    • OptionalavgSize: number

      Average size per tile in bytes

    Returns number

    Estimated size in bytes

• calculateResourcesSize: function

  • calculateResourcesSize(resources: ResourceWithSize[]): number

    Calculate total size of resources

    Parameters

    • resources: ResourceWithSize[]

      Array of resource objects with size property

    Returns number

    Total size in bytes

• formatBytes: function

  • formatBytes(bytes: number, decimals?: number): string

    Format bytes to human-readable string

    Parameters

    • bytes: number

      Size in bytes

    • Optionaldecimals: number = 2

      Number of decimal places

    Returns string

    Formatted string (e.g., "1.23 MB")

• estimateDownloadTime: function

  • estimateDownloadTime(bytes: number, speedMbps?: number): number

    Estimate download time based on size and connection speed

    Parameters

    • bytes: number

      Size in bytes

    • OptionalspeedMbps: number = 10

      Connection speed in Mbps

    Returns number

    Estimated time in seconds

• formatDuration: function

  • formatDuration(seconds: number): string

    Format time duration to human-readable string

    Parameters

    • seconds: number

      Duration in seconds

    Returns string

    Formatted string (e.g., "2h 30m 15s")

• _tileCount: function

  • _tileCount(bounds: Bounds, zoom: number): number

    How many tiles cover bounds at zoom — the figure the per-zoom cap is judged on.

    Parameters

    • bounds: Bounds

      Area covered.

    • zoom: number

      Zoom level.

    Returns number

    The tile count.

• enumerateTiles: function

  • enumerateTiles(
        layerConfig: LayerConfigWithBounds,
        _profileId: string,
        trace?: TilePreparationTrace,
    ): Promise<{ url: string; type: string; x: number; y: number; z: number }[]>

    Enumerate all tile URLs for a layer or basemap

    Parameters

    • layerConfig: LayerConfigWithBounds

      Layer or basemap configuration; supplies the bounds and zoom range.

    • _profileId: string

      Unused, kept for call-shape compatibility with the sibling members.

    • Optionaltrace: TilePreparationTrace

      Where to record the zooms left out and a stop at the total cap, so the preparation can be read back later; nothing is recorded without one.

    Returns Promise<{ url: string; type: string; x: number; y: number; z: number }[]>

    One entry per tile, { url, type: "tile", x, y, z }.