@maptiler/sdk 2.2.1 → 2.3.0

package/dist/src/Minimap.d.ts

@@ -0,0 +1,58 @@
+import { Map as SDKMap, MapOptions } from './Map';
+import { ControlPosition, CustomLayerInterface, FillLayerSpecification, FilterSpecification, IControl, LayerSpecification, LineLayerSpecification, SourceSpecification, StyleOptions, StyleSetterOptions, StyleSpecification, StyleSwapOptions } from 'maplibre-gl';
+import { MapStyleVariant, ReferenceMapStyle } from '@maptiler/client';
+
+export interface ParentRect {
+    lineLayout: LineLayerSpecification["layout"];
+    linePaint: LineLayerSpecification["paint"];
+    fillPaint: FillLayerSpecification["paint"];
+}
+export interface MinimapOptionsInput {
+    /**
+     * Style of the map. Can be:
+     * - a full style URL (possibly with API key)
+     * - a shorthand with only the MapTIler style name (eg. `"streets-v2"`)
+     * - a longer form with the prefix `"maptiler://"` (eg. `"maptiler://streets-v2"`)
+     */
+    style?: ReferenceMapStyle | MapStyleVariant | StyleSpecification | string;
+    /**
+     * Set the zoom difference between the parent and the minimap
+     * If the parent is zoomed to 10 and the minimap is zoomed to 8, the zoomAdjust should be 2
+     * Default: -4
+     */
+    zoomAdjust?: number;
+    /** Set a zoom of the minimap and don't allow any future changes */
+    lockZoom?: number;
+    /** Adjust the pitch only if the user requests */
+    pitchAdjust?: boolean;
+    /** Set CSS properties of the container using object key-values */
+    containerStyle?: Record<string, string>;
+    /** Set the position of the minimap at either "top-left", "top-right", "bottom-left", or "bottom-right" */
+    position?: ControlPosition;
+    /** Set the parentRect fill and/or line options */
+    parentRect?: ParentRect;
+}
+export interface MinimapOptions extends MapOptions {
+    zoomAdjust: number;
+    pitchAdjust: boolean;
+    containerStyle: Record<string, string>;
+    parentRect?: ParentRect;
+}
+export default class Minimap implements IControl {
+    #private;
+    map: SDKMap;
+    constructor(options: MinimapOptionsInput, mapOptions: MapOptions);
+    setStyle(style: null | ReferenceMapStyle | MapStyleVariant | StyleSpecification | string, options?: StyleSwapOptions & StyleOptions): void;
+    addLayer(layer: (LayerSpecification & {
+        source?: string | SourceSpecification;
+    }) | CustomLayerInterface, beforeId?: string): SDKMap;
+    moveLayer(id: string, beforeId?: string): SDKMap;
+    removeLayer(id: string): this;
+    setLayerZoomRange(layerId: string, minzoom: number, maxzoom: number): this;
+    setFilter(layerId: string, filter?: FilterSpecification | null, options?: StyleSetterOptions): this;
+    setPaintProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
+    setLayoutProperty(layerId: string, name: string, value: any, options?: StyleSetterOptions): this;
+    setGlyphs(glyphsUrl: string | null, options?: StyleSetterOptions): this;
+    onAdd(parentMap: SDKMap): HTMLElement;
+    onRemove(): void;
+}

package/dist/src/Point.d.ts

@@ -0,0 +1,177 @@
+/**
+ * This is TypeScript rewrite of the Point class to use instead of the version imported in MapLibre.
+ * It also uses a class instead of prototypes.
+ */
+/**
+ * Row major 2x2 matrix
+ */
+export type Matrix2 = [number, number, number, number];
+/**
+ * a point
+ */
+export declare class Point {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    private _matMult;
+    private _add;
+    private _sub;
+    private _mult;
+    private _div;
+    private _multByPoint;
+    private _divByPoint;
+    private _unit;
+    private _perp;
+    private _rotate;
+    private _rotateAround;
+    private _round;
+    /**
+     * Clone this point, returning a new point that can be modified
+     * without affecting the old one.
+     * @return {Point} the clone
+     */
+    clone(): Point;
+    /**
+     * Add this point's x & y coordinates to another point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    add(p: Point): Point;
+    /**
+     * Subtract this point's x & y coordinates to from point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    sub(p: Point): Point;
+    /**
+     * Multiply this point's x & y coordinates by point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    multByPoint(p: Point): Point;
+    /**
+     * Divide this point's x & y coordinates by point,
+     * yielding a new point.
+     * @param {Point} p the other point
+     * @return {Point} output point
+     */
+    divByPoint(p: Point): Point;
+    /**
+     * Multiply this point's x & y coordinates by a factor,
+     * yielding a new point.
+     * @param {Number} k factor
+     * @return {Point} output point
+     */
+    mult(k: number): Point;
+    /**
+     * Divide this point's x & y coordinates by a factor,
+     * yielding a new point.
+     * @param {Point} k factor
+     * @return {Point} output point
+     */
+    div(k: number): Point;
+    /**
+     * Rotate this point around the 0, 0 origin by an angle a,
+     * given in radians
+     * @param {Number} a angle to rotate around, in radians
+     * @return {Point} output point
+     */
+    rotate(a: number): Point;
+    /**
+     * Rotate this point around p point by an angle a,
+     * given in radians
+     * @param {Number} a angle to rotate around, in radians
+     * @param {Point} p Point to rotate around
+     * @return {Point} output point
+     */
+    rotateAround(a: number, p: Point): Point;
+    /**
+     * Multiply this point by a 4x1 transformation matrix
+     * @param {Array<Number>} m transformation matrix
+     * @return {Point} output point
+     */
+    matMult(m: Matrix2): Point;
+    /**
+     * Calculate this point but as a unit vector from 0, 0, meaning
+     * that the distance from the resulting point to the 0, 0
+     * coordinate will be equal to 1 and the angle from the resulting
+     * point to the 0, 0 coordinate will be the same as before.
+     * @return {Point} unit vector point
+     */
+    unit(): Point;
+    /**
+     * Compute a perpendicular point, where the new y coordinate
+     * is the old x coordinate and the new x coordinate is the old y
+     * coordinate multiplied by -1
+     * @return {Point} perpendicular point
+     */
+    perp(): Point;
+    /**
+     * Return a version of this point with the x & y coordinates
+     * rounded to integers.
+     * @return {Point} rounded point
+     */
+    round(): Point;
+    /**
+     * Return the magnitude of this point: this is the Euclidean
+     * distance from the 0, 0 coordinate to this point's x and y
+     * coordinates.
+     * @return {Number} magnitude
+     */
+    mag(): number;
+    /**
+     * Judge whether this point is equal to another point, returning
+     * true or false.
+     * @param {Point} other the other point
+     * @return {boolean} whether the points are equal
+     */
+    equals(other: Point): boolean;
+    /**
+     * Calculate the distance from this point to another point
+     * @param {Point} p the other point
+     * @return {Number} distance
+     */
+    dist(p: Point): number;
+    /**
+     * Calculate the distance from this point to another point,
+     * without the square root step. Useful if you're comparing
+     * relative distances.
+     * @param {Point} p the other point
+     * @return {Number} distance
+     */
+    distSqr(p: Point): number;
+    /**
+     * Get the angle from the 0, 0 coordinate to this point, in radians
+     * coordinates.
+     * @return {Number} angle
+     */
+    angle(): number;
+    /**
+     * Get the angle from this point to another point, in radians
+     * @param {Point} b the other point
+     * @return {Number} angle
+     */
+    angleTo(b: Point): number;
+    /**
+     * Get the angle between this point and another point, in radians
+     * @param {Point} b the other point
+     * @return {Number} angle
+     */
+    angleWith(b: Point): number;
+    angleWithSep(x: number, y: number): number;
+    /**
+     * Construct a point from an array if necessary, otherwise if the input
+     * is already a Point, or an unknown type, return it unchanged
+     * @param {Array<number> | Point} a any kind of input value
+     * @return {Point} constructed point, or passed-through value.
+     * @example
+     * // this
+     * var point = Point.convert([0, 1]);
+     * // is equivalent to
+     * var point = new Point(0, 1);
+     */
+    static convert(a: Point | Array<number>): Point;
+}

package/dist/src/caching.d.ts

@@ -0,0 +1,5 @@
+import { ResourceType } from 'maplibre-gl';
+
+export declare const CACHE_API_AVAILABLE: boolean;
+export declare function localCacheTransformRequest(reqUrl: URL, resourceType?: ResourceType): string;
+export declare function registerLocalCacheProtocol(): void;

package/dist/src/colorramp.d.ts

@@ -0,0 +1,359 @@
+export type RgbaColor = [number, number, number] | [number, number, number, number];
+export type ColorStop = {
+    /**
+     * The "value" at which this ColorStop should be applied.
+     */
+    value: number;
+    /**
+     * RGB[A] - Array of 3-4 numbers. 0-255 per channel.
+     */
+    color: RgbaColor;
+};
+/**
+ * A RGBA color as per the array definition
+ */
+export type ArrayColor = [number, number, number, number];
+/**
+ * A color ramp stop as per array definition
+ */
+export type ArrayColorRampStop = [
+    /**
+     * Real world value in a real world unit
+     */
+    number,
+    /**
+     * Color RGBA
+     */
+    ArrayColor
+];
+/**
+ * A color ramp as per array definition
+ */
+export type ArrayColorRamp = Array<ArrayColorRampStop>;
+export type ColorRampOptions = {
+    /**
+     * The value the colorramp starts
+     */
+    min?: number;
+    /**
+     * The value the colorramp ends
+     */
+    max?: number;
+    /**
+     * Some color stops to copy from
+     */
+    stops?: Array<ColorStop>;
+};
+export declare class ColorRamp extends Array<ColorStop> {
+    /**
+     * Converts a array-definition color ramp definition into a usable ColorRamp instance.
+     * Note: units are not converted and may need to to be converted beforehand (eg. kelvin to centigrade)
+     * @param cr
+     * @returns
+     */
+    static fromArrayDefinition(cr: ArrayColorRamp): ColorRamp;
+    private min;
+    private max;
+    constructor(options?: ColorRampOptions);
+    setStops(stops: Array<ColorStop>, options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    scale(min: number, max: number, options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    at(pos: number): ColorStop;
+    clone(): ColorRamp;
+    getRawColorStops(): Array<ColorStop>;
+    reverse(options?: {
+        clone?: boolean;
+    }): ColorRamp;
+    getBounds(): {
+        min: number;
+        max: number;
+    };
+    getColor(value: number, options?: {
+        smooth?: boolean;
+    }): RgbaColor;
+    /**
+     * Get the color as an hexadecimal string
+     */
+    getColorHex(value: number, options?: {
+        smooth?: boolean;
+        withAlpha?: boolean;
+    }): string;
+    /**
+     * Get the color of the color ramp at a relative position in [0, 1]
+     */
+    getColorRelative(value: number, options?: {
+        smooth?: boolean;
+    }): RgbaColor;
+    getCanvasStrip(options?: {
+        horizontal?: boolean;
+        size?: number;
+        smooth?: boolean;
+    }): HTMLCanvasElement;
+    /**
+     * Apply a non-linear ressampling. This will create a new instance of ColorRamp with the same bounds.
+     */
+    resample(method: "ease-in-square" | "ease-out-square" | "ease-in-sqrt" | "ease-out-sqrt" | "ease-in-exp" | "ease-out-exp", samples?: number): ColorRamp;
+    /**
+     * Makes a clone of this color ramp that is fully transparant at the begining of their range
+     */
+    transparentStart(): ColorRamp;
+    /**
+     * Check if this color ramp has a transparent start
+     */
+    hasTransparentStart(): boolean;
+}
+/**
+ * This is a collection of built-in color ramps. They are all defined in the range [0, 1]
+ * but can be scaled or reversed to fit specific usages.
+ */
+export declare const ColorRampCollection: {
+    /**
+     * A fully transparent [0, 0, 0, 0] colorramp to hide data.
+     * Defined in interval [0, 1], without unit.
+     */
+    NULL: ColorRamp;
+    GRAY: ColorRamp;
+    /**
+     * Classic jet color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    JET: ColorRamp;
+    /**
+     * Classic HSV color ramp (hue, saturation, value).
+     * Defined in interval [0, 1], without unit.
+     */
+    HSV: ColorRamp;
+    /**
+     * Classic hot color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    HOT: ColorRamp;
+    /**
+     * Classic spring color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SPRING: ColorRamp;
+    /**
+     * Classic summer color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SUMMER: ColorRamp;
+    /**
+     * Classic autommn color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    AUTOMN: ColorRamp;
+    /**
+     * Classic winter color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    WINTER: ColorRamp;
+    /**
+     * Classic bone color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BONE: ColorRamp;
+    /**
+     * Classic copper color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    COPPER: ColorRamp;
+    /**
+     * Classic greys color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    GREYS: ColorRamp;
+    /**
+     * Classic yignbu color ramp (blue to light yellow).
+     * Defined in interval [0, 1], without unit.
+     */
+    YIGNBU: ColorRamp;
+    /**
+     * Classic greens color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    GREENS: ColorRamp;
+    /**
+     * Classic yiorrd color ramp (red to light yellow).
+     * Defined in interval [0, 1], without unit.
+     */
+    YIORRD: ColorRamp;
+    /**
+     * Classic blue-red color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BLUERED: ColorRamp;
+    /**
+     * Classic rdbu color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RDBU: ColorRamp;
+    /**
+     * Classic picnic color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PICNIC: ColorRamp;
+    /**
+     * Classic rainbow color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RAINBOW: ColorRamp;
+    /**
+     * Classic Portland color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PORTLAND: ColorRamp;
+    /**
+     * Classic blackbody color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BLACKBODY: ColorRamp;
+    /**
+     * Classic earth color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    EARTH: ColorRamp;
+    /**
+     * Classic electric color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    ELECTRIC: ColorRamp;
+    /**
+     * Classic viridis color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VIRIDIS: ColorRamp;
+    /**
+     * Classic inferno color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    INFERNO: ColorRamp;
+    /**
+     * Classic magma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    MAGMA: ColorRamp;
+    /**
+     * Classic plasma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PLASMA: ColorRamp;
+    /**
+     * Classic warm color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    WARM: ColorRamp;
+    /**
+     * Classic cool color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    COOL: ColorRamp;
+    /**
+     * Classic rainboz soft color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    RAINBOW_SOFT: ColorRamp;
+    /**
+     * Classic bathymetry color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    BATHYMETRY: ColorRamp;
+    /**
+     * Classic cdom color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CDOM: ColorRamp;
+    /**
+     * Classic chlorophyll color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CHLOROPHYLL: ColorRamp;
+    /**
+     * Classic density color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    DENSITY: ColorRamp;
+    /**
+     * Classic freesurface blue color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    FREESURFACE_BLUE: ColorRamp;
+    /**
+     * Classic freesurface red color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    FREESURFACE_RED: ColorRamp;
+    /**
+     * Classic oxygen color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    OXYGEN: ColorRamp;
+    /**
+     * Classic par color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PAR: ColorRamp;
+    /**
+     * Classic phase color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    PHASE: ColorRamp;
+    /**
+     * Classic salinity color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    SALINITY: ColorRamp;
+    /**
+     * Classic temperature color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    TEMPERATURE: ColorRamp;
+    /**
+     * Classic turbidity color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    TURBIDITY: ColorRamp;
+    /**
+     * Classic velocity blue color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VELOCITY_BLUE: ColorRamp;
+    /**
+     * Classic velocity green color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    VELOCITY_GREEN: ColorRamp;
+    /**
+     * Classic cube helix color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    CUBEHELIX: ColorRamp;
+    /**
+     * The cividis color ramp is color blind friendly.
+     * Read more here https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0199239
+     * Defined in interval [0, 1], without unit.
+     */
+    CIVIDIS: ColorRamp;
+    /**
+     * Classic turbo color ramp.
+     * This is a luminance-constant alternative to the jet, making it more
+     * clor-blind friendly.
+     * Defined in interval [0, 1], without unit.
+     */
+    TURBO: ColorRamp;
+    /**
+     * The rocket color ramp is perceptually uniform, which makes it more
+     * color bliend friendly than the classic magma color ramp.
+     * Defined in interval [0, 1], without unit.
+     */
+    ROCKET: ColorRamp;
+    /**
+     * The mako color ramp is perceptually uniform and can be seen as
+     * a color blind friendly alternative to bathymetry or yignbu.
+     * Defined in interval [0, 1], without unit.
+     */
+    MAKO: ColorRamp;
+};

package/dist/src/config.d.ts

@@ -0,0 +1,68 @@
+import { default as EventEmitter } from 'events';
+import { LanguageInfo } from './language';
+import { FetchFunction } from '@maptiler/client';
+import { Unit } from './unit';
+
+export declare const MAPTILER_SESSION_ID: string;
+/**
+ * Configuration class for the SDK
+ */
+declare class SdkConfig extends EventEmitter {
+    /**
+     * The primary language. By default, the language of the web browser is used.
+     */
+    primaryLanguage: LanguageInfo;
+    /**
+     * The secondary language, to overwrite the default language defined in the map style.
+     * This settings is highly dependant on the style compatibility and may not work in most cases.
+     */
+    secondaryLanguage?: LanguageInfo;
+    /**
+     * Setting on whether of not the SDK runs with a session logic.
+     * A "session" is started at the initialization of the SDK and finished when the browser
+     * page is being refreshed.
+     * When `session` is enabled (default: true), the extra URL param `mtsid` is added to queries
+     * on the MapTiler Cloud API. This allows MapTiler to enable "session based billing".
+     */
+    session: boolean;
+    /**
+     * Enables client-side caching of requests for tiles and fonts.
+     * The cached requests persist multiple browser sessions and will be reused when possible.
+     * Works only for requests to the MapTiler Cloud API when sessions are enabled.
+     */
+    caching: boolean;
+    /**
+     * Unit to be used
+     */
+    private _unit;
+    /**
+     * MapTiler Cloud API key
+     */
+    private _apiKey;
+    /**
+     * Set the unit system
+     */
+    set unit(u: Unit);
+    /**
+     * Get the unit system
+     */
+    get unit(): Unit;
+    /**
+     * Set the MapTiler Cloud API key
+     */
+    set apiKey(k: string);
+    /**
+     * Get the MapTiler Cloud API key
+     */
+    get apiKey(): string;
+    /**
+     * Set a the custom fetch function to replace the default one
+     */
+    set fetch(f: FetchFunction);
+    /**
+     * Get the fetch fucntion
+     */
+    get fetch(): FetchFunction | null;
+}
+declare const config: SdkConfig;
+export { config, SdkConfig };

package/dist/src/converters/index.d.ts

@@ -0,0 +1 @@
+export * from './xml';