# Code coverage report for TileLayerOffline.ts

# All files TileLayerOffline.ts

90.9% Statements 20/22
66.66% Branches 8/12
80% Functions 4/5
90.47% Lines 19/21

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102

    10x

    10x
    10x

    10x

    10x

    10x

    10x

    10x

    10x

    13x

    15x
    15x
    15x
    90x
    90x

    90x

    15x

    2x

    2x

     import {
      Bounds,
      Coords,
      DomEvent,
      DoneCallback,
      TileLayer,
      TileLayerOptions,
      Util,
    } from 'leaflet';
    import {
      getTileUrl,
      TileInfo,
      getTilePoints,
      getTileImageSource,
    } from './TileManager';

    export class TileLayerOffline extends TileLayer {
      _url!: string;

      createTile(coords: Coords, done: DoneCallback): HTMLElement {
        const tile = document.createElement('img');

        DomEvent.on(tile, 'load', Util.bind(this._tileOnLoad, this, done, tile));
        DomEvent.on(tile, 'error', Util.bind(this._tileOnError, this, done, tile));

        Iif (this.options.crossOrigin || this.options.crossOrigin === '') {
          tile.crossOrigin =
            this.options.crossOrigin === true ? '' : this.options.crossOrigin;
        }

        tile.alt = '';

        tile.setAttribute('role', 'presentation');

        getTileImageSource(
          this._getStorageKey(coords),
          this.getTileUrl(coords),
        ).then((src) => (tile.src = src));

        return tile;
      }

      /**
       * get key to use for storage
       * @private
       * @param  {string} url url used to load tile
       * @return {string} unique identifier.
       */
      _getStorageKey(coords: { x: number; y: number; z: number }) {
        return getTileUrl(this._url, {
          ...coords,
          ...this.options,
          // @ts-ignore: Possibly undefined
          s: this.options.subdomains['0'],
        });
      }

      /**
       * Get tileinfo for zoomlevel & bounds
       */
      getTileUrls(bounds: Bounds, zoom: number): TileInfo[] {
        const tiles: TileInfo[] = [];
        const tilePoints = getTilePoints(bounds, this.getTileSize());
        for (let index = 0; index < tilePoints.length; index += 1) {
          const tilePoint = tilePoints[index];
          const data = {
            ...this.options,
            x: tilePoint.x,
            y: tilePoint.y,
            z: zoom + (this.options.zoomOffset || 0),
          };
          tiles.push({
            key: getTileUrl(this._url, {
              ...data,
              s: this.options.subdomains?.[0],
            }),
            url: getTileUrl(this._url, {
              ...data,
              // @ts-ignore: Undefined
              s: this._getSubdomain(tilePoint),
            }),
            z: zoom,
            x: tilePoint.x,
            y: tilePoint.y,
            urlTemplate: this._url,
            createdAt: Date.now(),
          });
        }
        return tiles;
      }
    }

    export function tileLayerOffline(url: string, options: TileLayerOptions) {
      return new TileLayerOffline(url, options);
    }

    /**  @ts-ignore */
    if (window.L) {
      /**  @ts-ignore */
      window.L.tileLayer.offline = tileLayerOffline;
    }