@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/source/tile_cache.js

@@ -1,212 +0,0 @@
-// @flow
-
-import {OverscaledTileID} from './tile_id';
-import type Tile from './tile';
-
-/**
- * A [least-recently-used cache](http://en.wikipedia.org/wiki/Cache_algorithms)
- * with hash lookup made possible by keeping a list of keys in parallel to
- * an array of dictionary of values
- *
- * @private
- */
-class TileCache {
-    max: number;
-    data: {[key: string]: Array<{ value: Tile, timeout: ?TimeoutID}>};
-    order: Array<string>;
-    onRemove: (element: Tile) => void;
-    /**
-     * @param {number} max number of permitted values
-     * @param {Function} onRemove callback called with items when they expire
-     */
-    constructor(max: number, onRemove: (element: Tile) => void) {
-        this.max = max;
-        this.onRemove = onRemove;
-        this.reset();
-    }
-
-    /**
-     * Clear the cache
-     *
-     * @returns {TileCache} this cache
-     * @private
-     */
-    reset() {
-        for (const key in this.data) {
-            for (const removedData of this.data[key]) {
-                if (removedData.timeout) clearTimeout(removedData.timeout);
-                this.onRemove(removedData.value);
-            }
-        }
-
-        this.data = {};
-        this.order = [];
-
-        return this;
-    }
-
-    /**
-     * Add a key, value combination to the cache, trimming its size if this pushes
-     * it over max length.
-     *
-     * @param {OverscaledTileID} tileID lookup key for the item
-     * @param {*} data any value
-     *
-     * @returns {TileCache} this cache
-     * @private
-     */
-    add(tileID: OverscaledTileID, data: Tile, expiryTimeout: number | void) {
-        const key = tileID.wrapped().key;
-        if (this.data[key] === undefined) {
-            this.data[key] = [];
-        }
-
-        const dataWrapper = {
-            value: data,
-            timeout: undefined
-        };
-
-        if (expiryTimeout !== undefined) {
-            dataWrapper.timeout = setTimeout(() => {
-                this.remove(tileID, dataWrapper);
-            }, expiryTimeout);
-        }
-
-        this.data[key].push(dataWrapper);
-        this.order.push(key);
-
-        if (this.order.length > this.max) {
-            const removedData = this._getAndRemoveByKey(this.order[0]);
-            if (removedData) this.onRemove(removedData);
-        }
-
-        return this;
-    }
-
-    /**
-     * Determine whether the value attached to `key` is present
-     *
-     * @param {OverscaledTileID} tileID the key to be looked-up
-     * @returns {boolean} whether the cache has this value
-     * @private
-     */
-    has(tileID: OverscaledTileID): boolean {
-        return tileID.wrapped().key in this.data;
-    }
-
-    /**
-     * Get the value attached to a specific key and remove data from cache.
-     * If the key is not found, returns `null`
-     *
-     * @param {OverscaledTileID} tileID the key to look up
-     * @returns {*} the data, or null if it isn't found
-     * @private
-     */
-    getAndRemove(tileID: OverscaledTileID): ?Tile {
-        if (!this.has(tileID)) { return null; }
-        return this._getAndRemoveByKey(tileID.wrapped().key);
-    }
-
-    /*
-     * Get and remove the value with the specified key.
-     */
-    _getAndRemoveByKey(key: string): ?Tile {
-        const data = this.data[key].shift();
-        if (data.timeout) clearTimeout(data.timeout);
-
-        if (this.data[key].length === 0) {
-            delete this.data[key];
-        }
-        this.order.splice(this.order.indexOf(key), 1);
-
-        return data.value;
-    }
-
-    /*
-     * Get the value with the specified (wrapped tile) key.
-     */
-    getByKey(key: string): ?Tile {
-        const data = this.data[key];
-        return data ? data[0].value : null;
-    }
-
-    /**
-     * Get the value attached to a specific key without removing data
-     * from the cache. If the key is not found, returns `null`
-     *
-     * @param {OverscaledTileID} tileID the key to look up
-     * @returns {*} the data, or null if it isn't found
-     * @private
-     */
-    get(tileID: OverscaledTileID): ?Tile {
-        if (!this.has(tileID)) { return null; }
-
-        const data = this.data[tileID.wrapped().key][0];
-        return data.value;
-    }
-
-    /**
-     * Remove a key/value combination from the cache.
-     *
-     * @param {OverscaledTileID} tileID the key for the pair to delete
-     * @param {Tile} value If a value is provided, remove that exact version of the value.
-     * @returns {TileCache} this cache
-     * @private
-     */
-    remove(tileID: OverscaledTileID, value: ?{ value: Tile, timeout: ?TimeoutID}) {
-        if (!this.has(tileID)) { return this; }
-        const key = tileID.wrapped().key;
-
-        const dataIndex = value === undefined ? 0 : this.data[key].indexOf(value);
-        const data = this.data[key][dataIndex];
-        this.data[key].splice(dataIndex, 1);
-        if (data.timeout) clearTimeout(data.timeout);
-        if (this.data[key].length === 0) {
-            delete this.data[key];
-        }
-        this.onRemove(data.value);
-        this.order.splice(this.order.indexOf(key), 1);
-
-        return this;
-    }
-
-    /**
-     * Change the max size of the cache.
-     *
-     * @param {number} max the max size of the cache
-     * @returns {TileCache} this cache
-     * @private
-     */
-    setMaxSize(max: number): TileCache {
-        this.max = max;
-
-        while (this.order.length > this.max) {
-            const removedData = this._getAndRemoveByKey(this.order[0]);
-            if (removedData) this.onRemove(removedData);
-        }
-
-        return this;
-    }
-
-    /**
-     * Remove entries that do not pass a filter function. Used for removing
-     * stale tiles from the cache.
-     *
-     * @param {function} filterFn Determines whether the tile is filtered. If the supplied function returns false, the tile will be filtered out.
-     */
-    filter(filterFn: (tile: Tile) => boolean) {
-        const removed = [];
-        for (const key in this.data) {
-            for (const entry of this.data[key]) {
-                if (!filterFn(entry.value)) {
-                    removed.push(entry);
-                }
-            }
-        }
-        for (const r of removed) {
-            this.remove(r.value.tileID, r);
-        }
-    }
-}
-
-export default TileCache;

package/src/source/tile_id.js

@@ -1,402 +0,0 @@
-// @flow
-
-import { getTileBBox as getMecartorBBox } from "@mapbox/whoots-js";
-import EXTENT from "../data/extent";
-import Point from "@mapbox/point-geometry";
-import MercatorCoordinate from "../geo/mercator_coordinate";
-
-import assert from "assert";
-import { register } from "../util/web_worker_transfer";
-import { TileUrlReplaceSpecification } from "../style-spec/types";
-
-import CRS from "../ui/crs";
-
-export class CanonicalTileID {
-    z: number;
-    x: number;
-    y: number;
-    z_replace: string;
-    y_replace: string;
-    x_replace: string;
-    key: string;
-
-    constructor(z: number, x: number, y: number) {
-        assert(z >= 0 && z <= 25);
-        assert(x >= 0 && x < Math.pow(2, z));
-        assert(y >= 0 && y < Math.pow(2, z));
-        this.z = z;
-        this.x = x;
-        this.y = y;
-        this.key = calculateKey(0, z, z, x, y);
-        this.z_replace = undefined;
-        this.x_replace = undefined;
-        this.y_replace = undefined;
-    }
-
-    offsetZ(offset: number) {
-        if (offset) {
-            this.z += offset;
-        }
-    }
-
-    replaceX(x: any) {
-        this.x_replace = x;
-    }
-
-    replaceY(y: any) {
-        this.y_replace = y;
-    }
-
-    replaceZ(z: any) {
-        this.z_replace = z;
-    }
-
-    format(str, size) {
-        //截取右8位，不足的位数前面补0
-        var i = str.length;
-        if (i >= size) {
-            str = str.substring(i - size, i);
-        } else {
-            var str0 = "";
-            for (let i = 0; i < size; i++) {
-                str0 += "0";
-            }
-            str = str0.substring(0, str0.length - i) + str;
-        }
-        return str;
-    }
-
-    replaceRule(replace: TileUrlReplaceSpecification, value): string {
-        const { type, fixlength, prefix, postfix } = replace;
-        let str = value;
-        let fix = 0;
-        switch (type) {
-            case "hex":
-                str = value.toString(16).toUpperCase();
-                break;
-            case "dec":
-                str = value.toString(10).toUpperCase();
-                break;
-            case "oct":
-                str = value.toString(8).toUpperCase();
-                break;
-            case "bin":
-                str = value.toString(2).toUpperCase();
-                break;
-            case "replace":
-                break;
-        }
-        if (fixlength) {
-            str = this.format(str, fixlength)
-        }
-
-        if (prefix) {
-            str = prefix + str;
-        }
-        if (postfix) {
-            str = str + postfix;
-        }
-        return str;
-    }
-
-    equals(id: CanonicalTileID) {
-        return this.z === id.z && this.x === id.x && this.y === id.y;
-    }
-
-    // given a list of urls, choose a url template and return a tile URL
-    url(urls: Array<string>, scheme: ?string) {
-        const { x_replace, y_replace, z_replace } = this;
-        const url = urls[(this.x + this.y) % urls.length];
-        const reverse = url.indexOf("reversebbox=true") >= 0 ? true : false;
-        let bbox = this.getTileBBox(this.x, this.y, this.z);
-        if (reverse) {
-            let bound = bbox.split(",");
-            bbox = `${bound[1]},${bound[0]},${bound[3]},${bound[2]}`;
-            console.warn("reverse", bbox);
-        }
-        // const bbox3857 = getTileBBox(this.x, this.y, this.z);
-        // const bbox4326 = getLatlngBBox(this.x, this.y, this.z);
-        const quadkey = getQuadkey(this.z, this.x, this.y);
-        let z_rule = this.z,
-            x_rule = this.x,
-            y_rule = this.y;
-
-        if (x_replace || y_replace || z_replace) {
-            if (z_replace) {
-                z_rule = this.replaceRule(z_replace, this.z);
-            }
-            if (x_replace) {
-                x_rule = this.replaceRule(x_replace, this.x);
-            }
-            if (y_replace) {
-                y_rule = this.replaceRule(y_replace, this.y);
-            }
-        }
-
-        return url
-            .replace(
-                "{prefix}",
-                (this.x % 16).toString(16) + (this.y % 16).toString(16)
-            )
-            .replace("{z}", String(z_rule))
-            .replace("{x}", String(x_rule))
-            .replace(
-                "{y}",
-                String(
-                    scheme === "tms" ? Math.pow(2, this.z) - this.y - 1 : y_rule
-                )
-            )
-            .replace("{quadkey}", quadkey)
-            .replace("{bbox}", bbox);
-    }
-
-    getTilePoint(coord: MercatorCoordinate) {
-        const tilesAtZoom = Math.pow(2, this.z);
-        return new Point(
-            (coord.x * tilesAtZoom - this.x) * EXTENT,
-            (coord.y * tilesAtZoom - this.y) * EXTENT
-        );
-    }
-
-    getTileBBox(x, y, z) {
-        return getMecartorBBox(x, y, z);
-    }
-
-    getCRS() {
-        return CRS.EPSG3857;
-    }
-
-    toString() {
-        return `${this.z}/${this.x}/${this.y}`;
-    }
-}
-
-export class UnwrappedTileID {
-    wrap: number;
-    canonical: CanonicalTileID;
-    key: string;
-
-    constructor(wrap: number, canonical: CanonicalTileID) {
-        this.wrap = wrap;
-        this.canonical = canonical;
-        this.key = calculateKey(
-            wrap,
-            canonical.z,
-            canonical.z,
-            canonical.x,
-            canonical.y
-        );
-    }
-}
-
-export class OverscaledTileID {
-    overscaledZ: number;
-    wrap: number;
-    canonical: CanonicalTileID;
-    key: string;
-    posMatrix: Float32Array;
-
-    constructor(
-        overscaledZ: number,
-        wrap: number,
-        z: number,
-        x: number,
-        y: number
-    ) {
-        assert(overscaledZ >= z);
-        this.overscaledZ = overscaledZ;
-        this.wrap = wrap;
-        this.canonical = new CanonicalTileID(z, +x, +y);
-        this.key = calculateKey(wrap, overscaledZ, z, x, y);
-    }
-
-    equals(id: OverscaledTileID) {
-        return (
-            this.overscaledZ === id.overscaledZ &&
-            this.wrap === id.wrap &&
-            this.canonical.equals(id.canonical)
-        );
-    }
-
-    scaledTo(targetZ: number) {
-        assert(targetZ <= this.overscaledZ);
-        const zDifference = this.canonical.z - targetZ;
-        if (targetZ > this.canonical.z) {
-            return new OverscaledTileID(
-                targetZ,
-                this.wrap,
-                this.canonical.z,
-                this.canonical.x,
-                this.canonical.y
-            );
-        } else {
-            return new OverscaledTileID(
-                targetZ,
-                this.wrap,
-                targetZ,
-                this.canonical.x >> zDifference,
-                this.canonical.y >> zDifference
-            );
-        }
-    }
-
-    /*
-     * calculateScaledKey is an optimization:
-     * when withWrap == true, implements the same as this.scaledTo(z).key,
-     * when withWrap == false, implements the same as this.scaledTo(z).wrapped().key.
-     */
-    calculateScaledKey(targetZ: number, withWrap: boolean): string {
-        assert(targetZ <= this.overscaledZ);
-        const zDifference = this.canonical.z - targetZ;
-        if (targetZ > this.canonical.z) {
-            return calculateKey(
-                this.wrap * +withWrap,
-                targetZ,
-                this.canonical.z,
-                this.canonical.x,
-                this.canonical.y
-            );
-        } else {
-            return calculateKey(
-                this.wrap * +withWrap,
-                targetZ,
-                targetZ,
-                this.canonical.x >> zDifference,
-                this.canonical.y >> zDifference
-            );
-        }
-    }
-
-    isChildOf(parent: OverscaledTileID) {
-        if (parent.wrap !== this.wrap) {
-            // We can't be a child if we're in a different world copy
-            return false;
-        }
-        const zDifference = this.canonical.z - parent.canonical.z;
-        // We're first testing for z == 0, to avoid a 32 bit shift, which is undefined.
-        return (
-            parent.overscaledZ === 0 ||
-            (parent.overscaledZ < this.overscaledZ &&
-                parent.canonical.x === this.canonical.x >> zDifference &&
-                parent.canonical.y === this.canonical.y >> zDifference)
-        );
-    }
-
-    children(sourceMaxZoom: number) {
-        if (this.overscaledZ >= sourceMaxZoom) {
-            // return a single tile coord representing a an overscaled tile
-            return [
-                new OverscaledTileID(
-                    this.overscaledZ + 1,
-                    this.wrap,
-                    this.canonical.z,
-                    this.canonical.x,
-                    this.canonical.y
-                ),
-            ];
-        }
-
-        const z = this.canonical.z + 1;
-        const x = this.canonical.x * 2;
-        const y = this.canonical.y * 2;
-        return [
-            new OverscaledTileID(z, this.wrap, z, x, y),
-            new OverscaledTileID(z, this.wrap, z, x + 1, y),
-            new OverscaledTileID(z, this.wrap, z, x, y + 1),
-            new OverscaledTileID(z, this.wrap, z, x + 1, y + 1),
-        ];
-    }
-
-    isLessThan(rhs: OverscaledTileID) {
-        if (this.wrap < rhs.wrap) return true;
-        if (this.wrap > rhs.wrap) return false;
-
-        if (this.overscaledZ < rhs.overscaledZ) return true;
-        if (this.overscaledZ > rhs.overscaledZ) return false;
-
-        if (this.canonical.x < rhs.canonical.x) return true;
-        if (this.canonical.x > rhs.canonical.x) return false;
-
-        if (this.canonical.y < rhs.canonical.y) return true;
-        return false;
-    }
-
-    wrapped() {
-        return new OverscaledTileID(
-            this.overscaledZ,
-            0,
-            this.canonical.z,
-            this.canonical.x,
-            this.canonical.y
-        );
-    }
-
-    unwrapTo(wrap: number) {
-        return new OverscaledTileID(
-            this.overscaledZ,
-            wrap,
-            this.canonical.z,
-            this.canonical.x,
-            this.canonical.y
-        );
-    }
-
-    overscaleFactor() {
-        return Math.pow(2, this.overscaledZ - this.canonical.z);
-    }
-
-    toUnwrapped() {
-        return new UnwrappedTileID(this.wrap, this.canonical);
-    }
-
-    toString() {
-        return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;
-    }
-
-    getTilePoint(coord: MercatorCoordinate) {
-        return this.canonical.getTilePoint(
-            new MercatorCoordinate(coord.x - this.wrap, coord.y)
-        );
-    }
-}
-
-function calculateKey(
-    wrap: number,
-    overscaledZ: number,
-    z: number,
-    x: number,
-    y: number
-): string {
-    wrap *= 2;
-    if (wrap < 0) wrap = wrap * -1 - 1;
-    const dim = 1 << z;
-    return (
-        (dim * dim * wrap + dim * y + x).toString(36) +
-        z.toString(36) +
-        overscaledZ.toString(36)
-    );
-}
-
-function getQuadkey(z, x, y) {
-    let quadkey = "",
-        mask;
-    for (let i = z; i > 0; i--) {
-        mask = 1 << (i - 1);
-        quadkey += (x & mask ? 1 : 0) + (y & mask ? 2 : 0);
-    }
-    return quadkey;
-}
-
-function getLatlngBBox(x, y, z) {
-    let bbox = "";
-    let scale = 360 / Math.pow(2, z);
-    let left = scale * x - 180;
-    let right = scale * (x + 1) - 180;
-    let top = 90 - scale * y;
-    let bottom = 90 - scale * (y + 1);
-    bbox = left + "," + bottom + "," + right + "," + top;
-    return bbox;
-}
-
-register("CanonicalTileID", CanonicalTileID);
-register("OverscaledTileID", OverscaledTileID, { omit: ["posMatrix"] });