diff --git a/mapsjs/mapsjs.d.ts b/mapsjs/mapsjs.d.ts new file mode 100644 index 000000000..c43fd5d56 --- /dev/null +++ b/mapsjs/mapsjs.d.ts @@ -0,0 +1,2639 @@ +/** + * Mapsjs 9.6.0 Copyright (c) 2013 ISC. All Rights Reserved. +*/ + +declare module 'mapsjs' { + + /** + * Clusters a set of points. + * @param {object} options An options object which specifies the clustering algorithm. + * @returns {object} An array of clustered points. + */ + export function clusterPoints(options: { + data: {}[]; + pointKey: string; + valueFunction?: (row: any) => number; + radiusFunction: (row: any) => number; + aggregateFunction?: (srcRow: any, cmpRow: any, aggRow: any) => void; + mapUnitsPerPixel: number; + marginPixels?: number; + }): {}[]; + + /** + * An immutable envelope + * @class envelope + */ + export class envelope { + constructor(minX: number, minY: number, maxX: number, maxY: number); + + /** + * Gets the minimum x coordinate of the envelope. + * @returns {number} The minimum x coordinate. + */ + getMinX(): number; + + /** + * Gets the minimum y coordinate of the envelope + * @returns {number} The minimum y coordinate. + */ + getMinY(): number; + + /** + * Gets the maximum x coordinate of the envelope + * @returns {number} The maximum x coordinate. + */ + getMaxX(): number; + + /** + * Gets the maximum y coordinate of the envelope + * @returns {number} The maximum y coordinate. + */ + getMaxY(): number; + + /** + * Creates a new envelope from this as deep copy. + * @returns {envelope} The new cloned envelope. + */ + clone(): envelope; + + /** + * Creates a new envelope from this one plus x and y margins. + * @param {number} marginX The x margin. + * @param {number} marginY The y margin. + * @returns {envelope} A new envelope. + */ + createFromMargins(marginX: number, marginY: number): envelope; + + /** + * Create a new envelope from this one plus a bleed ratio. + * @param {number} bleed The bleed ratio. + * @returns {envelope} A new envelope. + */ + createFromBleed(bleed: number): envelope; + + /** + * Gets the center point of the envelope. + * @returns {point} Center as a point. + */ + getCenter(): point; + + /** + * Gets the width of the envelope. + * @returns {number} Width of the envelope. + */ + getWidth(): number; + + /** + * Gets height of the envelope. + * @returns {number} Height of the envelope. + */ + getHeight(): number; + + /** + * Gets area of the envelope. + * @return {number} Area of the envelope. + */ + getArea(): number; + + /** + * Returns the minimum and maximum coordinates of this envelope as an envObject. + * @returns {envObject} Representaton of this envelope as an envObject. + */ + toObject(): envObject; + + /** + * Gets upper left coordinate of this envelope. + * @returns {point} A new point. + */ + getUL(): point; + + /** + * Gets upper right of this envelope. + * @returns {point} A new point. + */ + getUR(): point; + + /** + * Gets lower left of this envelope. + * @returns {point} A new point. + */ + getLL(): point; + + /** + * Gets lower right of this envelope. + * @returns {point} A new point. + */ + getLR(): point; + + /** + * Gets the aspect of the envelope. + * @returns {number} Width-to-height ratio. + */ + getAspect(): number; + + /** + * Equality comparer between this and another envelope. + * @param {envelope} env Envelope to compare. + * @return {boolean} Result of equality comparison. + */ + equals(env: envelope): boolean; + + /** + * Method for casting this envelope as a string. + * @returns {string} String of the form 'minX,minY,maxX,maxY'. + */ + toString(): string; + + /** + * Create a closed geometry from this envelope. + * @returns {geometry} A new closed path geometry. + */ + toGeometry(): geometry; + + /** + * Tests whether the given point is contained within this envelope. + * @param {point} pt Point to test. + * @returns {boolean} Result of containment test. + */ + contains(pt: point): boolean; + } + + /** + * Exposes static functions that act on or return envelopes. + * @module envelope + */ + export module envelope { + + /** + * Creates a new envelope from MapDotNet XML. + * @param {string} xml A MapDotNet XML string of the envelope. + * @returns {envelope} A new envelope + */ + export function createFromMdnXml(xml: string): envelope; + + /** + * Creates new envelope from two corner points. + * @param {point} pt1 Corner point + * @param {point} pt2 Opposite corner point + * @returns {envelope} A new envelope + */ + export function createFromPoints(pt1: point, pt2: point): envelope; + + /** + * Creates a new envelope from the x and y coordinates of the center + * point and x and y margins from the center point. + * @param {number} centerPtX The center x coordinate. + * @param {number} centerPtY The center y coordinate. + * @param {number} marginX The margin from center x coordinate. + * @param {number} marginY The margin from center y coordinate. + * @returns {envelope} A new envelope + */ + export function createFromCenterAndMargins(centerPtX: number, centerPtY: number, marginX: number, marginY: number): envelope; + + /** + * Tests whether two given envelopes intersect. + * @param {envelope} env1 First envelope to test. + * @param {envelope} env2 Second envelope to test. + * @returns {boolean} Result of the intersection test. + */ + export function intersects(env1: envelope, env2: envelope): boolean; + + /** + * Creates a new envelope from the union of two given envelopes. + * @param {envelope} env1 The first enevelope to unite. + * @param {envelope} env2 The second envelope to unite. + * @returns {envelope} A new envelope. + */ + export function union(env1: envelope, env2: envelope): envelope; + } + + /** + * A general geometry which can represent a point, line, polygon, + * mulitpoint, multilinestring + * @class geometry + */ + export class geometry { + constructor(isPath?: boolean, isClosed?: boolean); + + /** + * Creates a new polygon or polyline form the geometry according to + * whether the geometry is closed. + * @returns {any} A new polyline or polygon geometry. + */ + factoryPoly(): any; + + /** + * Creates a deep copy of this geometry. + * @returns {geometry} The new cloned geometry. + */ + clone(): geometry; + + /** + * Iterates every vertex in the geometry and passes to the supplied + * callback. Return true from in the callback will break the iteration. + * @param {function} action Callback with the signature action(setIdx, idx, x, y, set). + */ + foreachVertex(action: (setIdx: number, idx: number, x: number, y: number, s: number[]) => void): void; + + /** + * Returns the geometry's bounding box as an envelope. + * @returns {envelope} The bounding box of the geometry as an envelope. + */ + getBounds(): envelope; + + /** + * Checks whether or not this geometry is closed. + * @returns {boolean} Result of the path check. + */ + getIsPath(): boolean; + + /** + * Checks whether or not this geometry is closed. + * @returns {boolean} Result of the closed check. + */ + getIsClosed(): boolean; + + /** + * Gets the number of sets in this geometry. + * @returns {number} Number of sets. + */ + getSetCount(): number; + + /** + * Gets a set from this geometry's set collection by index, or, if no + * index is provided, gets the last set. Note: for polygons, first set + * is primary ring and subsequent ones are holes. + * @param {number} [idx] Index of the set to return. + * @returns {number[]} A set as an array of points in the form [xn,yn]. + */ + getSet(idx: number): number[]; + + /** + * Adds a new set to this geometry's collection of sets. + * @param {number[]} s Set to add as an array of points in the form [xn,yn]. + */ + pushSet(s: number[]): void; + + /** + * Gets the last set in the geometry's set collection and removes it + * from the collection. + * @returns {number} Set removed as an array of points in the form [xn,yn]. + */ + popSet(): number[]; + + /** + * Creates SVG path data from this geometry if it is a path. + * @returns {string} String of the SVG path or null the geometry is not a path. + */ + toSvgPathData(): string; + + /** + * Adds point to the last set in geometry's set collection. If the + * geometry is empty, a new set is added to the geometry first. + * @param {point} pt The point to add. + * @returns {object} Object of the form {setIdx, idx} where setIdx is + * the 0-based index of the set the point was added to and idx is the + * 0-based index of the point in its set. + */ + addPointToLastSet(pt: point): { setIdx: number; idx: number; }; + + /** + * Tests the validity of this geometry. An open path geometry is valid + * if it has at least one set with at least two points. A closed + * geometry is valid if it has at least one set with at least three + * points. A point (non-path) geometry is always valid. + * @returns {geometry} valid geometry is true, otherwise false. + */ + isValid(): boolean; + + /** + * Creates a wkt string from this geometry. + * @returns {string} A string of well known text. + */ + toString(): string; + toWkt(): string; + + /** + * Finds the point in this geometry nearest to the given point. + * @param {point} pt Reference point. + * @returns {object} An object of the form {setIdx, ptIdx, pt, distance} + * where setIdx is the index of the set the point is in, ptIdx is the + * index of the point in the set, pt is the point object, and distance + * is the distance of the point to the reference point in map units. + */ + findNearestVertex(pt: point): { setIdx: number; ptIdx: number; pt: point; distance: number; }; + + /** + * Finds point along boundary of geometry nearest to the given point + * @param {point} pt Reference point. + * @param {boolean} [close] Flag to indicate whether this geometry + * should be treated as a closed geometry. + * @returns {object} An object of the form {setIdx, ptIdx, pt, distance} + * where setIdx is the index of the set the point is in, ptIdx is the + * index of the point in the set, pt is the point object, and distance + * is the distance of the point to the reference point in map units. + */ + findNearestSegment(pt: point, close?: boolean): { setIdx: number; ptIdx: number; pt: point; distance: number; }; + + /** + * Finds coordinates in map units of the midpoint of this geometry. If + * this geometry is an open path, the midpoint is the midpoint of the + * path. If this geometry is a closed path, the midpoint is the centroid + * of the polygon. If a set index is not provided, finds the labeling + * point for the last set in this geometry's set collection. + * @param {number} [idx] Index of set for which to find the labeling point. + * @returns {point} Midpoint of this geometry. + */ + getLabelingPoint(idx?: number): point; + + /** + * Tests whether this geometry contains a given point/ + * @param {point} pt The reference point. + * @returns {boolean} Result of the containment test. + */ + contains(pt: point): boolean; + } + + /** + * Exposes static functions that act on or return geometries, including + * constructors for specific geometries such as polygon and polyline. + * @module geometry + */ + export module geometry { + + /** + * A polyline object which is an open path geometry with one or more paths. + * @class polyline + */ + class polyline extends geometry { + constructor(geom: geometry); + + /** + * Gets the underlying geometry of the polyline. + * @returns {geometry} The polyline's underlying geometry object. + */ + getGeometry(): geometry; + + /** + * Creates a new polyline object from a deep copy of the underlying geometry. + * @returns {polyline} Thew new cloned polyline. + */ + clone(): polyline; + + /** + * Gets number of lines in this polyline. + * @returns {number} Number of lines. + */ + getLineCount(): number; + + /** + * Gets a line from this polyline's liune collection by index, or, + * if no index is provided, gets the last line. + * @param {number} [idx] Index of the line to return. + * @returns {number[]} A line as an array of points in the form [xn,yn]. + */ + getLine(idx: number): number[]; + + /** + * Adds a new line to this polyline's line collection. + * @param {number[]} s Line to add as an array of points in the form [xn,yn]. + */ + pushLine(s: number[]): void; + + /** + * Gets the last line in the polyline's set collection and removes it + * from the collection. + * @returns {number} Line removed as an array of points in the form [xn,yn]. + */ + popLine(): number[]; + + /** + * Calculates distance of a line in a polyline by index according + * to projected map cooordinates. If no index is provided, uses + * the last line in the polyline's set collection. + * @param {number} [idx] Index of the line for which to compute the distance. + * @returns {number} Length in projected units of the distance of the line. + */ + getProjectedDistance(idx: number): number; + + /** + * Calculates distance of a line in a polyline by index according + * to actual distance. If no index is provided, uses the last line + * in the polyline's set collection. + * @param {number} [idx] Index of the line for which to compute the distance. + * @returns {number} Distance in meters of the line. + */ + getActualDistance(idx: number): number; + + /** + * Determines whether this polyline intersects a given geometry. + * @param {geometry} geom Geometry to test against. + * @returns {boolean} Result of the intersection test. + */ + intersects(geom: geometry): boolean; + } + + /** + * A polyline object which is a closed path geometry with one or more paths. + * @class polygon + */ + class polygon extends geometry { + constructor(geom: geometry); + + /** + * Gets the underlying geometry of the polygon. + * @returns {geometry} The polygon's underlying geometry object. + */ + getGeometry(): geometry; + + /** + * Creates a new polygon object from a deep copy of the underlying geometry. + * @returns {polygon} Thew new cloned polygon. + */ + clone(): polygon; + + /** + * Gets number of rings in this polygon. + * @returns {number} Number of rings. + */ + getRingCount(): number; + + /** + * Gets a ring from this polygon's set collection by index, or, + * if no index is provided, gets the last ring. + * @param {number} [idx] Index of the ring to return. + * @returns {number[]} A ring as an array of points in the form [xn,yn]. + */ + getRing(idx: number): number[]; + + /** + * Adds a new ring to this polygon's ring collection. + * @param {number[]} s Ring to add as an array of points in the form [xn,yn]. + */ + pushRing(s: number[]): void; + + /** + * Gets the last ring in the polygon's ring collection and removes it + * from the collection. + * @returns {number} Ring removed as an array of points in the form [xn,yn]. + */ + popRing(): number[]; + + /** + * Calculates area of a ring in a polygon by index according + * to projected map cooordinates. If no index is provided, uses + * the last ring in the polygon's ring collection. + * @param {number} [idx] Index of the ring for which to compute the area. + * @returns {number} Area in square projected units of the ring. + */ + getProjectedArea(idx: number): number; + + /** + * Calculates perimeter of a ring in a polygon by index according + * to projected map cooordinates. If no index is provided, uses + * the last ring in the polygon's ring collection. + * @param {number} [idx] Index of the ring for which to compute the perimeter. + * @returns {number} Length in projected units of the distance of the ring. + */ + getProjectedPerimeter(idx: number): number; + + /** + * Calculates area of a ring in a polygon by index according + * to the actual area. If no index is provided, uses the last ring + * in the polygon's ring collection. + * @param {number} [idx] Index of the ring for which to compute the area. + * @returns {number} Area in square meters of the ring. + */ + getActualArea(idx: number): number; + + /** + * Calculates perimeter of a ring in a polygon by index according + * to actual distance. If no index is provided, uses the last ring + * in the polygon's ring collection. + * @param {number} [idx] Index of the ring for which to compute the perimeter. + * @returns {number} Length in meters of the perimeter of the ring. + */ + getActualPerimeter(idx: number): number; + + /** + * Determines whether this polygon intersects a given geometry. + * @param {geometry} geom Geometry to test against. + * @returns {boolean} Result of the intersection test. + */ + intersects(geom: geometry): boolean; + + /** + * Determines whether this polyline overlaps a given geometry. + * @param {geometry} geom Geometry to test against. + * @returns {boolean} Result of the intersection test. + */ + overlaps(poly: polygon): boolean; + + /** + * Convert this polygon into an array of OGC compliant polygons where + * the first set is a ring and all subsequent contained sets are holes. + * @returns {polygon[]} An array of OGC polygons. + */ + toMultiPolygon(): polygon[]; + } + } + + /** + * A style specification for geometry objects. + * @class geometryStyle + */ + export class geometryStyle { + constructor(); + + /** + * Gets path outline thickness in pixels. + * @returns {number} Thickness of path outline. + */ + getOutlineThicknessPix(): number; + + /** + * Sets path outline thickness in pixels. + * @param {number} t Desired thickness. + */ + setOutlineThicknessPix(t: number): void; + + /** + * Gets path outline color as a CSS style string. + * @returns {string} Outline color as a CSS style string. + */ + getOutlineColor(): string; + + /** + * Sets path outline color from a CSS style string. + * @param {string} c Outline color as a CSS style string. + */ + setOutlineColor(c: string): void; + + /** + * Gets path outline opacity in decimal format. + * @returns {number} Outline opacity. + */ + getOutlineOpacity(): number; + + /** + * Set path outline opacity to a decimal between 0 and 1. + * @param {number} o Outline opacity. + */ + setOutlineOpacity(o: number): void; + + /** + * Gets fill color as a CSS style string. + * @returns {string} Fill color as a CSS style string. + */ + getFillColor(): string; + + /** + * Sets fill color as a CSS style string. + * @param {string} c Fill color as a CSS style string. + */ + setFillColor(c: string): void; + + /** + * Gets fill opacity in decimal format. + * @returns {number} Fill opacity. + */ + getFillOpacity(): number; + + /** + * Sets fill opacity to a decimal between 0 and 1. + * @param {number} o Fill opacity. + */ + setFillOpacity(o: number): void; + + /** + * Gets the dash array as a string. + * @returns {string} Dash array as astring. + */ + getDashArray(): string; + + /** + * Sets dash array string from a CSS style string. Defaults to solid + * stroke if no dash array string is provided. + * @param {string} [da] Dash array as a CSS style string. + */ + setDashArray(da: string): void; + } + + /** + * Gets the mapsjs license. + * @returns {string} The license. + */ + export var license: string; + + /** + * A simple point class with x and y coordinates. + * @class point + */ + export class point { + + constructor(x: number, y: number); + + /** + * Returns the x coordinate. + * @returns {number} The x coordinate. + */ + getX(): number; + + /** + * Returns the y coordinate. + * @returns {number} The y coordinate. + */ + getY(): number; + + /** + * Returns the x and y coordinates of this point as a pointObject. + * @returns {pointObject} Representaton of this point as an pointObject. + */ + toProps(): pointObject; + + /** + * Equality comparer between this point and a given reference point. + * @param {point} pt Reference point. + * @returns {boolean} Result of the equality test. + */ + equals(pt: point): boolean; + + /** + * Creates a point from this point offset by a given x and y distance. + * @param {number} dx The x offset. + * @param {number} dy The y offset. + * @returns {point} The offset point. + */ + createOffsetBy(dx: number, dy: number): point; + + /** + * Creates new n-sided polygon around this point. + * @param {number} sides Number of polygon sides. + * @param {number} radius Distance to polygon points. + * @returns {polygon} The generated polygon. + */ + convertToPoly(side: number, radius: number): geometry.polygon; + + /** + * Gets the wkt representation of this point. + * @returns {string} The well known text for this point. + */ + toString(): string; + + /** + * Creates a deep copy of this point. + * @returns {point} The new cloned point. + */ + clone(): point; + + /** + * Returns this point's bounding box. + * @returns {envelope} The bounding box of the point as an envelope. + */ + getBounds(): envelope; + + /** + * Computes distance between this point and a given point in projected + * map units. + * @param {point} pt Point to which to compute distance. + * @returns {number} Distance from this point to the given point in + * projected map units. + */ + distanceTo(pt: point): number; + } + + /** + * Exposes static functions that act on points. + * @module point + */ + export module point { + + /** + * Computes the distance between two points in coordinate units. + * @param {number} x1 The x coordinate for the first point. + * @param {number} y1 The y coordinate for the first point. + * @param {number} x2 The x coordinate for the second point. + * @param {number} y2 The y coordinate for the second point. + * @returns {number} Distance in coordinate units. + */ + export function distance(x1: number, y1: number, x2: number, y2: number): number; + + /** + * Computes the midpoint of two points. + * @param {number} x1 The x coordinate for the first point. + * @param {number} y1 The y coordinate for the first point. + * @param {number} x2 The x coordinate for the second point. + * @param {number} y2 The y coordinate for the second point. + * @return {point} Midpoint point. + */ + export function midpoint(x1: number, y1: number, x2: number, y2: number): point; + } + + /** + * Exposes static functions related to the Spherical Mercator projection. + * @module sphericalMercator + */ + export module sphericalMercator { + + /** + * Gets the EPSG number for Spherical Mercator. + * @return {number} ESPG number. + */ + export function getEpsg(): number; + + /** + * Gets the minimum zoom level for this projection. + * @returns {number} Minimum zoom level. + */ + export function getMinZoomLevel(): number; + + /** + * Sets the minimum zoom level for this projection. Normally this is + * set to 1.0 and should not be altered. + * @param {number} minZ Desired minimum zoom level. + */ + export function setMinZoomLevel(minZ: number): void; + + /** + * Gets the maxmimum zoom level for this projection. + * @returns {number} Maximum zoom level. + */ + export function getMaxZoomLevel(): number; + + /** + * Sets the maximum zoom level for this projection. Normally this is + * set to 20.0 and should not be altered. + * @param {number} maxZ1 Desired maximum zoom level. + */ + export function setMaxZoomLevel(maxZ: number): void; + + /** + * Gets the tile height and width in pixels. + * @returns {number} The height and width of the tiles in pixels. + */ + export function getTileSizePix(): number; + + /** + * Gets the display DPI, which defaults to 96. Note: The dpi is + * recomputed on page load complete. + * @returns {number} Dots per inch on display. + */ + export function getDpi(): number; + + /** + * Set the display DPI, which defaults to 96. Note: The DPI is + * recomputed on page load complete. + * @param {number} dpi Dots per inch on display. + */ + export function setDpi(dpi: number): void; + + /** + * Return the equitorial radius in meters for this projection. + * @returns {number} Equitorial radius in meters. + */ + export function getRadius(): number; + + /** + * Returns equitorial circumference in meters for this projection + * @returns {number} Equitorial circumference in meters. + */ + export function getCircumference(): number; + + /** + * Returns half the equitorial circumference in meters for this projection + * @returns {number} Half of the equitorial circumference in meters. + */ + export function getHalfCircumference(): number; + + /** + * Get the envelope in map units for a given quadtree node, i.e. tile, + * based on the given x, y, and z quadtree coordinates. + * @param {number} x The x coordinate. + * @param {number} y The y coordinate. + * @param {number} z The z coordinate. + * @returns {envelope} Envelope of the tile in map units. + */ + export function getQuadTreeNodeToMapEnvelope(x: number, y: number, z: number): envelope; + + /** + * Gets the envelope in map units of tiles in the quadtree from an + * evelope in map units and a zoom level. + * @param {envelope} env Envelope for which to find intersecting tiles. + * @param {number} z Zoom level with which to test for intersection. + * @returns {envelope} The envelope in map units of the tiles. + */ + export function getQuadTreeNodeRangeFromEnvelope(env: envelope, z: number): envelope; + + /** + * Gets projected map units per pixel for a given zoom level. + * @param {number} zoomLevel Reference zoom level. + * @returns {number} Projection units per pixel. + */ + export function getProjectionUnitsPerPixel(zoomLevel: number): number; + + /** + * Gets the required scale transform to apply to shapes so distance + * and area computations yield actual Earth-geodesic units instead of + * projected map units. + * @param {number} mapPtY Reference latitude for the computation. + * @returns {number} Scale transform multiplier. + */ + export function getActualShapeScaleTransform(mapPtY: number): number; + + /** + * Gets actual, on-the-ground meters per pixel for a given zoom level + * and map point in map units. + * @param {point} mapPt Reference location for the computation. + * @param {number} z Reference zoom level. + * @returns {number} Meters per pixel multiplier. + */ + export function getActualUnitsPerPixel(mapPt: point, zoomLevel: number): number; + + /** + * Gets the optimal zoom level for a given envelope in map units + * based on the envelope of visible device area in pixels. + * @param {envelope} envelopeMap Envelope in map units to display. + * @param {envelope} envelopeDevice Envelope in pixels of visible area. + * @returns {number} Optimal zoom level for viewing envelopeMap. + */ + export function getBestFitZoomLevelByExtents(envelopeMap: envelope, envelopeDevice: envelope): number; + + /** + * Gets a quad-key from x, y, and z coordinates. + * @param {number} x The x coordinate. + * @param {number} y The y coordinate. + * @param {number} z The z coordinate. + * @returns {string} Quad-key string. + */ + export function getQuadKeyFromXYZ(x: number, y: number, z: number): string; + + /** + * Gets x, y, and z coordinates as an object from a given quad-key. + * @param {string} key Reference quad-key. + * @return {object} JavaScript object of the form {x,y,z}. + */ + export function getXYZFromQuadKey(key: string): { x: number; y: number; z: number; }; + + /** + * Project a point from latitude/longitude to Spherical Mercator. + * @param {point} lonLat Point object in latitude/longitude. + * @returns {point} The same point in Spherical Mercator. + */ + export function projectFromLatLon(lonLat: point): point; + + /** + * Project a point from Spherical Mercator to latitude/longitude. + * @param {point} mapPt Point object in Spherical Mercator. + * @returns {point} The same point in latitude/longitude. + */ + export function deprojectToLatLon(mapPt: point): point; + } + + /** + * A geometry object decorated with a geometry style object + * @class styledGeometry + */ + export class styledGeometry { + constructor(geom: geometry, gStyle: geometryStyle); + + /** + * Set this styledGeometry's geometryStyle. + * @param {geometryStyle} gs A new styledGeometry. + */ + setGeometryStyle(gs: geometryStyle): void; + + /** + * Gets the styledGeometry's underlying geometry object. + * @returns {geometry} The underlying geometry. + */ + getGeometry(): geometry; + + /** + * Gets path outline thickness in pixels. + * @returns {number} Thickness in pixels. + */ + getOutlineThicknessPix(): number; + + /** + * Sets path outline thickness in pixels. + * @param {number} t Thickness in pixels. + */ + setOutlineThicknessPix(t: number): void; + + /** + * Gets path outline color as a CSS style string. + * @returns {string} Outline color as a CSS style string. + */ + getOutlineColor(): string; + + /** + * Gets path outline opacity in decimal format. + * @returns {number} Outline opacity. + */ + setOutlineColor(c: string): void; + + /** + * Gets path outline opacity in decimal format. + * @returns {number} Outline opacity. + */ + getOutlineOpacity(): number; + + /** + * Set path outline opacity to a decimal between 0 and 1. + * @param {number} o Outline opacity. + */ + setOutlineOpacity(o: number): void; + + /** + * Gets fill color as a CSS style string. + * @returns {string} Fill color as a CSS style string. + */ + getFillColor(): string; + + /** + * Sets fill color as a CSS style string. + * @param {string} c Fill color as a CSS style string. + */ + setFillColor(c: string): void; + + /** + * Gets fill opacity in decimal format. + * @returns {number} Fill opacity. + */ + getFillOpacity(): number; + + /** + * Sets fill opacity to a decimal between 0 and 1. + * @param {number} o Fill opacity. + */ + setFillOpacity(o: number): void; + + /** + * Gets the dash array as a string. + * @returns {string} Dash array as astring. + */ + getDashArray(): string; + + /** + * Sets dash array string from a CSS style string. Defaults to solid + * stroke if no dash array string is provided. + * @param {string} [da] Dash array as a CSS style string. + */ + setDashArray(da: string): void; + + /** + * Gets optional animation function called when SVG node is created. + * @returns {function} Function with the signature animation(pathElement, loopback). + */ + getAnimation(): (pathElement: HTMLElement, loopback: () => void) => void; + + /** + * You can use the loopback parameter on complete to call itself and + * create repeating animation. + * @param {function} Function with the signature animation(pathElement, loopback). + */ + setAnimation(action: (pathElement: HTMLElement, loopback: () => void) => void): void; + + /** + * Renders this geometry as an SVG path. Note: We attach original + * geometry bounds to svg doc as an expando. + * @param {string} key Identifer to keep track of the SVG DOM element. + * @param {number} mupp Map units per pixel with which to create the SVG element. + * @returns {HTMLElement} A new SVG document root. + */ + createSvgPathElement(key: string, mapUnitsPerPix: number): HTMLElement; + + /** + * Renders this to a canvas context. + * @param {CanvasRenderingContext2D} ctx Canvas context to which to render. + */ + renderPathToCanvasContext(ctx: CanvasRenderingContext2D): void; + } + + /** + * The mapjs version. + */ + export var version: string; + + /** + * Exposes static functions for working with well known text. + * @module wkt + */ + export module wkt { + + /** + * Parses WKT as a point. + * @param {string} w A WKT string. + * @returns {point} The parsed point. + */ + export function parsePoint(wkt: string): point; + + /** + * Parses WKT as a multipoint. + * @param [string} w A WKT string. + * @retuns {geometry} The parsed multipoint geometry. + */ + export function parseMultiPoint(wkt: string): geometry; + + /** + * Parses WKT as an open path geometry with a single set. + * @param {string} w A WKT string. + * @returns {geometry} The parsed open path geometry. + */ + export function parseLineString(wkt: string): geometry; + + /** + * Parses WKT as an open path geometry with multiple sets. + * @param {string} w A WKT string. + * @returns {geometry} The parsed open path geometry. + */ + export function parseMultiLineString(wkt: string): geometry; + + /** + * Parses WKT as a closed path geometry with a single set. + * @param {string} w A WKT string. + * @returns {geometry} The parsed closed path geometry. + */ + export function parsePolygon(wkt: string): geometry; + + /** + * Parses WKT as a closed path geometry with multiple sets. + * @param {string} w A WKT string. + * @returns {geometry} The parsed closed path geometry. + */ + export function parseMultiPolygon(wkt: string): geometry; + + /** + * Parses WKT as a geometry and determines its type from the string. + * @param {string} w The WKT string. + * @returns {any} The parsed shape, a point, geometry, or an array of + * polygons depending on the WKT. + */ + export function parse(wkt: string): any; + + /** + * Converts an array of polygons to an OGC compliant multipolygon WKT string. + * @param {polygon[]} polys Set of polygons to parse into WKT. + * @returns {geometry} The OGC compliant WKT for the polygons. + */ + export function toMultiPolygonString(polys: geometry.polygon[]): string; + } + + /** + * Exposes various tile-related constructors, including layers, descriptors, + * and requestors. + * @module tile + */ + export module tile { + + /** + * A tile layer is a view on the map containing an array of rectangular content. + * @class layer + */ + export class layer { + constructor(id: string, useBackdrop?: boolean, maxConcurrentRequests?: number); + + /** + * @param {number} m - number for margin in pixels + */ + // setContentExtentsMarginInPixels(m: number): void; + + /** + * Gets ID associated with this tile layer. + * @returns {string} ID of the layer. + */ + getId(): string; + + /** + * Determines whether this tile layer uses a backdrop. + * @returns {boolean} Whether or not the layer uses a backdrop. + */ + getUseBackdrop(): boolean; + + /** + * Returns the tile layer's descriptor, which describes how + * requested content is rendered or styled. + * @returns {object} The tile layer's descriptor. + */ + getDescriptor(): any; + + /** + * Sets the tile layer's descriptor, which describes how requested + * content is rendered or styled. + * @param {function} d A descriptor for this tile layer. + */ + setDescriptor(d: any): void; + + /** + * Notifies the tile layer to check for changes to its descriptor. + */ + notifyDescriptorChange(): void; + + /** + * Returns this tile layer's requestor which defines what kind of + * content to get and where to get it. + * @returns {requestor} This tile layer's requestor. + */ + getRequestor(): tile.requestor; + + /** + * Sets this tile layer's requestor, which defines what kind of + * content to get and where to get it. + * @param {tile.requestor} req A requestor object. + * @param {tile.requestor} [desc] Descriptor object so that both + * can be set in one call and incur only one content change event. + */ + setRequestor(req: tile.requestor, desc?: any): void; + + /** + * Returns this tile layer's renderer if it exists, which defines + * how geometry data for a quadView is rendered. + * @returns {renderer} The renderer object. + */ + getRenderer(): tile.renderer; + + /** + * Sets optional renderer which defines how geometry data for + * quadView is rendered. + * @param {renderer} r The renderer delegate function with + * signature renderer(quadview). + */ + setRenderer(r: tile.renderer): void; + + /** + * Notifies the tile layer to check for changes to its renderer. + */ + notifyRendererChange(): void; + + /** + * Gets the visibility state of this tile layer. + * @returns {boolean} Whether or not this layer is visible. + */ + getIsVisible(): boolean; + + /** + * Sets visibility state of this tile layer. + * @param {boolean} v Whether this layer should be visible or not. + */ + setIsVisible(v: boolean): void; + + /** + * Gets the opacity of this tile layer. + * @returns {number} Opacity as a decimal. + */ + getOpacity(): number; + + /** + * Sets opacity of this tile layer. + * @param {number} o Opacity as a decimal. + */ + setOpacity(o: number): void; + + /** + * Gets minimum zoom level where this tile layer is visible. + * @returns {number} The minimum zoom level. + */ + getMinZoomLevel(): number; + + /** + * Sets minimum zoom level where this tile layer is visible. + * @param {number} minZ The desired minimum zoom level. + */ + setMinZoomLevel(minZ: number): void; + + /** + * Gets maximum zoom level where this tile layer is visible. + * @returns {number} The maximum zoom level. + */ + getMaxZoomLevel(): number; + + /** + * Sets maximum zoom level where this tile layer is visible. + * @param {number} maxZ The desired maximum zoom level. + */ + setMaxZoomLevel(maxZ: number): void; + + /** + * Sets pixel bleed on quadTiles, which defaults to 1. Setting this + * to zero for overlay layers with translucent polygon fills is + * recommended. Bleed overlap can create faint lines at tile + * boundries when fill is not opaque. + * @param {number} bleed The number of pixels to bleed. + */ + setTileBleedPix(bleed: number): void; + + /** + * Sets whether or not to retain and display previous level tile + * content as you change tile levels to provide a nice zoom level + * change effect. Once the next level is loaded the old level + * content is always discarded. This should be set to false if there + * is translucent content to display. Defaults to true (prior to + * version 9.0.0001 this value had the same state as useBackdrop.) + * @param {boolean} ret Whether or not to retain interlevel content. + */ + setRetainInterlevelContent(retain: boolean): void; + + /** + * Enables or disables the fade in on tile content, which defaults to enabled. + * @param {boolean} fadeIn Whether or not fade in on tile content + * should be enabled. + */ + setEnableTileFadeIn(fadeIn: boolean): void; + + /** + * Sets the default action to take on error. + * @param {function} action Function to execute on error. + */ + setNotifyErrorAction(action: () => void): void; + + /** + * Sets an optional function to be called when the tile loading + * queue for this layer has emptied. + * @param {function} action Callback function. + */ + setNotifyLoadingQueueHasEmptiedAction(action: () => void): void; + + /** + * Sets the optional function to be called by this layer's tile + * loader during processing. The supplied progress function takes + * tiles loaded and tiles total parameters. + * @param {function} action Callback of the signature action(tileLoaded, tilesTotal). + */ + setNotifyLoadingQueueProgressAction(action: (tilesLoaded: number, tilesTotal: number) => void): void; + + /** + * Sets optional request processor for this tile layer. This is + * an advanced feature allowing developers to tap into tile + * request pipeline for purposes of customizing requests or manage + * custom caching. This is also the mechanism used for offline + * apps with frameworks such as phonegap. + * @param {function} Processor function with signature + * processor(requestor, descriptor, quad, timeoutMs, complete, error) + */ + setRequestProcessor(processorFunc: ( + requestor: tile.requestor, + descriptor: any, + quad: tile.quad, + timeoutMs: number, + completeAction: (img: HTMLElement) => void, + errorAction: (msg: string) => void) => void): void; + + /** + * Instructs the tile loader to populate a specified tile pyramid. + * This is used to fetch content (e.g. bitmap tiles) and preload + * it into the browser cache. + * @param {envelope} extents Envelope for which to fetch content. + * @param {number} startZoomLevel Minimum zoom level for which to + * fetch content. + * @param {number} endZoomLevel Maximum zoom level for which to + * fetch content. + */ + preload(extents: envelope, startZoomLevel: number, endZoomLevel: number): void; + + /** + * Composes an array of quadtiles with composition information and + * requestor endpoints. This can be used to create static images + * or print-ready versions of this tile layer at arbitrary extents + * (both source and target) For example: If you needed a 5x3 inch + * 300 dpi output you can specify extents in device units to be + * 1500x900. This function determines the correct zoom level so + * that the source extents fits in the target extents to the + * nearest integer zoom level. + * @param {envelope} extentsMapUnits Source extents in map units. + * @param {envelope} extentsDeviceUnits Target extents in pixels. + * @returns {object} Composed object in the form + * {quadCollection, endpointCollection, idxMinX, idxMinY, ulX, ulY } + * where quadCollection is an array of quad objects, endpointCollection + * is an array of REST endpoints from which to obtain the tiled content, + * idxMinX and idxMinY are the minimum x and y tile indicies of the + * collection respectively, and ulX and ulY are the offset in pixels + * of the upper left tile from the upper left target extents. + */ + compose(extentsMapUnits: envelope, extentsDeviceUnits: envelope): { + quadCollection: tile.quad[]; + endpointCollection: string[]; + idxMinX: number; + idxMinY: number; + ulX: number; + ulY: number; + }; + } + + /** + * A layerOptions object is a method for constructing a tile layer for + * immediate use, for example by passing it to the jQuery widget or + * in the knockout binding. + * @class layerOptions + */ + export class layerOptions { + constructor(id: string, options: { + useBackdrop?: boolean; + maxConcurrentRequests?: number; + requestor?: tile.requestor; + descriptor?: any; + renderer?: tile.renderer; + requestProcessor?: any; + visible?: boolean; + opacity?: number; + minZoomLevel?: number; + maxZoomLevel?: number; + tileBleedPix?: number; + retainInterlevelContent?: boolean; + enableTileFadeIn?: boolean; + notifyErrorAction?: (msg?: string) => void; + notifyLoadingQueueHasEmptiedAction?: () => void; + }); + + /** + * Returns the underlying tile layer. + * @returns {layer} The underlying tile layer. + */ + getTileLayer(): tile.layer; + + /** + * Gets ID associated with the underlying tile layer. + * @returns {string} ID of the layer. + */ + getId(): string; + + /** + * Gets this layerOptions object as a JavaScript object. + */ + getOptions(): any; + } + + /** + * The quad class represents a quad tile within three dimensional + * coordinate space. + * @class quad + */ + export class quad { + + /** + * Gets the x coodinate of this quad tile. + * @returns {number} The x coordinate of this quad tile. + */ + getX(): number; + + /** + * Gets the y coordinate of this quad tile. + * @returns {number} The y coordinate of this quad tile. + */ + getY(): number; + + /** + * Gets the z coordinate of this quad tile, or depth. + * @returns {number} The z coordinate of this quad tile. + */ + getLevel(): number; + + /** + * Gets the envelope in map units which encompasses this quad tile. + * @returns {envelope} The encompassing envelope of this quad tile. + */ + getEnvelope(): envelope; + + /** + * Gets the string representation of this quad tile as a quad key. + * @returns {string} Quad key for this quad tile as a string. + */ + toString(): string; + + /** + * Gets the quad key for this quad tile as a string. + * @returns {string} Quad key for this quad tile as a string. + */ + getKey(): string; + + /** + * Compares this quad tile with another quad tile and determines + * whether or not they are equal. + * @param {quad} Quad tile with which to check for equality with this quad tile. + * @returns {boolean} Result of the equality test. + */ + equals(q: quad): boolean; + + /** + * Generates the quad tile which is a given number of levels above + * this tile in the pyramid and in which this quad tile is contained. + * @param {number} ancestorsBack Number of levels above this tile the + * generated tile should be. + * @returns {quad} The generated parent tile. + */ + factoryParent(ancestorsBack: number): quad; + } + + /** + * Exposes static functions for generating and handling quad tiles. + * @module quad + */ + export module quad { + + /** + * Generates a new quad tile based on a given quad key. + * @param {string} key The quad key from which to generate the quad tile. + * @returns The generated quad tile. + */ + export function factoryQuadFromKey(key: string): quad; + } + + /** + * A tile renderer handles converting JSON vector content loaded from the + * MapDotNet REST feature service into a canvas rendering on a tile. + * @class renderer + */ + export class renderer { + constructor(options? : { + renderPoint?: (pt: point, context: CanvasRenderingContext2D) => void; + renderGeometry?: (shape: geometry, context: CanvasRenderingContext2D) => void; + renderBitmap?: (img: HTMLElement, context: CanvasRenderingContext2D, contextSize: number, bleed: number) => void; + }); + + /** + * Sets the render point function which takes a point and canvas + * context and renders the point to the canvas. The points passed + * in are transformed to pixel units and offset to context origin. + * @param {function} func Function of the form func(shape, context) + * where shape is the point object to be rendered and context is the + * canvas context on which to render. + */ + setRenderPoint(func: (pt: point, context: CanvasRenderingContext2D) => void): void ; + + /** + * Sets render geometry function which takes a geometry and canvas + * context and renders the geometry to the canvas context. The + * geometries passed in are transformed to pixel units and offset + * to the context origin. + * @param {function} func Function with signature func(shape, context) + * where shape is the geometry to render and context is the canvas + * context on which to render. + */ + setRenderGeometry(func: (shape: geometry, context: CanvasRenderingContext2D) => void): void; + + /** + * Sets the render bitmap function which takes a bitmap image and + * a canvas context and renders the image to the canvas context. + * @param {function} func Function with the signature + * func(img, context, contextSize, bleed) where img is the bitmap + * image to render, context is the canvas context on which to + * render the image, contextSize is the size of the canvas context + * in pixels and bleed is the margin around each tile to bleed. + */ + setRenderBitmap(func: (img: HTMLElement, context: CanvasRenderingContext2D, contextSize: number, bleed: number) => void): void; + } + + /** + * An auto-ranging density map renderer. + * @class rendererDensityMap + */ + export class rendererDensityMap { + + constructor(); + + /** + * Sets the bleed ratio, which is the sets the percentage of the + * margin around each tile to use in the tile's computation. Note: + * some bleed (i.e., greater than 1) is required since a heat map + * relies on adjacent data. + * @param {number} bleed The desired bleed ratio. + */ + setBleed(bleed: number): void; + + /** + * Sets the number of rows and columns of cells to be used for + * computation within the grid. + * @param {number} gridSize Number of rows and columns used in + * the grid. + */ + setGridSize(gridSize: number): void; + + /** + * Sets filter radius corresponding to standard deviations. The + * filter radius is the cutoff point at which adjacent cells no + * longer contribute to a cell's calculation. + * @param {number} filterStdDevRadius Number of standard deviations + * from the mean of a normal distribution to which to give positive + * weight. + */ + setFilterStdDevRadius(filterStdDevRadius: number): void; + + /** + * Sets color ranges from cold to hot for the renderer. + * @param {number[][]} matrix Array of arrrays of numbers, each + * of the form [r,g,b,a], where each array represents a color and + * colors range from cold to hot. Note: Typically, a dozen colors + * is sufficient. + */ + setColorMatrix(matrix: number[][]): void; + + /** + * Sets the minimum required cell value for a cell to receive + * a color. Default minimum value is 0. + * @param {number} mcv The minimum cell value for painting. + */ + setMinCellValue(min: number): void; + + /** + * Sets an optional action to perform on each row. This enables + * processing the values on one or more columns for each row for + * use in the density map computations. + * @param {action} ra Function to call on each row with signature + * action(row). The value returned from the function will is added + * to the cell's value. + */ + setRowAction(action: (row: any) => number): void; + + /** + * Tells renderer to re-render density map and recompute ranges. + * This should be called if the data changes or if, due to extent + * changes, the density changes. + */ + notifyRecompute(): void; + } + + /** + * This is a base requestor class. + * @class requestor + */ + export class requestor { + + constructor(); + + /** + * Gets formatted endpoint using the supplied quadtile and a descriptor. + * @param {quad} quad Quadtile for which to fetch the endpoint. + * @returns {string} The requested URI string. + */ + getFormattedEndpoint(quad: quad, descriptor: any): string; + + /** + * Gets data locally if the requestor supports it. + * @param {quad} quad Quadtile for which to fetch the endpoint. + * @returns {string} The requested JSON data. + */ + getLocalData(quad: quad, descriptor: any): string; + + /** + * Creates unique sha1 hash from this requestor and the supplied + * descriptor. This is useful in creating a unique key or folder + * for tile caching. This combined with a tile's quad-key can + * efficiently and uniquely identify a particular tile. + * @params {descriptor} The descriptor for which to create the hash. + * @returns {string} The generated sha1 hash. + */ + hash(descriptor: any): string; + + /** + * Determines whether or not this requestor returns bitmap images. + * @returns {boolean} Whether or not this requestor returns bitmap + * images. + */ + getIsRestImage(): boolean; + + /** + * Sets whether this requestor should return bitmap images. + * @param {boolean} flag Whether or not this requestor should return + * bitmap images. + */ + setIsRestImage(flag: boolean): void; + + /** + * Determines whether or not this requestor uses an endpoint + * rather than local data. + * @returns {boolean} Whether or not this requestor gets data from + * an endpoint. + */ + getUsesEndpoint(): boolean; + + /** + * Sets whether or not this requestor uses an endpoint rather than + * local data. + * @param {boolean} Whether or not this requestor should get data + * from an endpoint. + */ + setUsesEndpoint(flag: boolean): void; + + /** + * Gets format of data returned by REST service. + * @returns {string} Data format returned by the REST service. + */ + getDataFormat(): string; + + /** + * Sets format of data that should be returned by REST service. + * @param {string} df Name of the data format the REST service + * should use. + */ + setDataFormat(df: string): void; + + /** + * Returns whether or not caching is enabled for vector-based + * requestors. + * @returns {boolean} Whether or not caching is enabled. + */ + getCacheEnabled(): boolean; + + /** + * Sets whether or not caching is enabled for vector-beased requestors. + * @param {boolean} flagce - true (default) if caching is enabled + */ + setCacheEnabled(flag: boolean): void; + + /** + * Gets requestor timeout in miliseconds. + * @returns {number} Requestor timeout in miliseconds. + */ + getTimeoutMs(): number; + + /** + * Sets requestor timeout in miliseconds. + * @param {number} ms Desired requestor timeout in miliseconds. + */ + setTimeoutMs(ms: number): void; + + /** ??? + * Gets the additional + * @returns {object[]} + */ + getKeyVals(): {}[]; + + /** Set any key/value pairs that are attached to the ajax call (such as username and password) + */ + setKeyVals(options: {}[]): void; + + /** + * Gets maximum available zoom level content that can be retrieved + * from the endpoint this requestor consumes. + * @returns {number} The maximum available zoom level for this requestor. + */ + getMaxAvailableZoomLevel(): number; + + /** + * Sets maximum available zoom level content that can be retrieved + * from the endpoint this requestor consumes. Note: This defaults + * to the projection's maximum available zoom level, which is 20 + * in spherical mercator. + * @param {number} max The maximum available zoom level for this requestor. + */ + setMaxAvailableZoomLevel(max: number): void; + } + + /** + * A tile requestor for Microsoft Bing maps. + * @class requestorBing + */ + export class requestorBing extends requestor { + + constructor(options?: { + dataFormat?: string; + timeoutMs?: number; + maxAvailableZoomLevel?: number; + }); + + /** + * Gets the formatted endpoint uri for Bing maps, e.g. + * ecn.t{0}.tiles.virtualearth.net/tiles/{1}{2}{3}?g={4}&mkt={5}&shading=hill. + * @returns {string} endpoint to Bing tile server as a formatted string + */ + getEndpoint(): string; + + /** + * Gets the protocol for the endpoint, either 'http' or 'https'. + * @returns {string} The endpoint protocol. + */ + getScheme(): string; + + /** + * Sets endpoint protocol to either 'http' or 'https'. + * @param {string} s Protocol to use in endpoints. + */ + setScheme(s: string): void; + + /** + * Gets Bing tile generation + * @returns {string} the tile generation as an integer + */ + getGeneration(): string; + + /** + * Sets Bing tile generation + * @param {string} g - generation as an integer + */ + setGeneration(g: string): void; + + /** + * Gets the language code for which the tiles are rendered. The + * default code is 'en-US'. + * @returns {string} The language code for which tiles are rendered. + */ + getMarket(): string; + + /** + * Sets language code for which to render tiles. For example, + * 'en-US'. + * @param {string} m Language code for which to render tiles. + */ + setMarket(m: string): void; + + /** + * Gets the Bing key associated with this requestor. + * @returns {string} The Bing key for this requestor. + */ + getBingKey(): string; + + /** + * Sets Bing key which then calls Microsoft metadata service and + * automatically configures content endpoint. + * @param {string} key Bing key. + */ + setBingKey(key: string): void; + } + + /** + * The bitmap or vector tile requestor using MapDotNet REST services. + * @class requestorMDN + */ + export class requestorMDN extends requestor { + constructor(endpoint: string, options?: { + dataFormat?: string; + timeoutMs?: number; + maxAvailableZoomLevel?: number; + }); + + /** + * Gets uri endpoint for the MapDotNet REST service. + * @returns {string} Uri endpoint for the MapDotNet REST service. + */ + getEndpoint(): string; + } + + /** + * Creates an instance of a descriptor for describing content from a + * MapDotNet UX REST map service. + * @class descriptorMDNRestMap + */ + export class descriptorMDNRestMap { + constructor(mapId: string, options?: { + version?: string; + imageType?: string; + bleedRatio?: number; + mapCacheOption?: string; + mapCacheName?: string; + useQuadKeyForMapCacheName?: boolean; + backgroundColorStr?: string; + layerVisibility?: {}; + layerOutline?: {}; + layerFill?: {}; + layerWhere?: {}; + tag?: string; + }); + + /** + * Sets the flag to suspend descriptor change notifications. If + * set true, all changes to this descriptor will not cause the map + * to redraw. Setting to false will enable redraws and immediately + * force a redraw. + * @param {boolean} flag Whether or not descriptor change notifications + * should be enabled. + */ + setSuspendDescriptorChangeNotifications(flag: boolean): void; + + /** + * Gets the map ID. + * @returns {string} The map ID. + */ + getMapId(): string; + + /** + * Gets the REST service version. + * @returns {string} The REST service version. + */ + getVersion(): string; + + /** + * Sets the REST service version. + * @param {string} v The version number. + */ + setVersion(v: string): void; + + /** + * Gets image type associated with this descriptor, either 'png', + * 'png8', or 'jpg'. + * @returns {string} The image type associated with this descriptor. + */ + getImageType(): string; + + /** + * Gets image type associated with this descriptor to one of 'png', + * 'png8', or 'jpg'. + * @param {string} t The image type associated which should be + * associated with this descriptor. + */ + setImageType(t: string): void; + + /** + * Gets bleed ratio for the layer associated with this descriptor. + * @returns {number} The bleed ratio. + */ + getBleedRatio(): number; + + /** + * Sets the bleed ratio. Bleeds greater than 1.0 will fetch content + * beyond the edge of the tile extents (this is useful for point + * features). + * @param {number} br The desired bleed ratio, between 1.0 and 2.0. + */ + setBleedRatio(br: number): void; + + /** + * Gets the map's cache setting, which is one of 'None', + * 'ReadOnly', 'ReadWrite', 'ForceWrite', and 'Default.' + * @returns {string} The map's cache setting. + */ + getMapCacheOption(): string; + + /** + * Gets the map's cache setting to one of 'None', + * 'ReadOnly', 'ReadWrite', 'ForceWrite', and 'Default.' + * @param {string} mco The desired cache setting for the map. + */ + setMapCacheOption(mco: string): void; + + /** + * Gets the optional map cache name. + * @returns {string} The map cache name. + */ + getMapCacheName(): string; + + /** + * Sets the optional map cache name. + * @param {string} mcn The desired map cache name. + */ + setMapCacheName(mcn: string): void; + + /** + * Determines whether the map is flagged to use the quadkey as its + * map cache name. + * @returns {boolean} Whether or not the map has been flagged to + * use the quadkey as its map cache name. + */ + getUseQuadKeyForMapCacheName(): boolean; + + /** + * Sets the flag that uses the quadkey as its map cache name. + * @param {boolean} flag Whether or not the map should be flagged + * to use the quadkey as its map cache name. + */ + setUseQuadKeyForMapCacheName(flag: boolean): void; + + /** + * Gets map image background color. + * @returns {string} CSS style string for the map image background color. + */ + getBackgroundColorStr(): string; + + /** + * Sets the map image background color. + * @param {number} a Alpha level. + * @param {number} r Red level. + * @param {number} g Green level. + * @param {number} b Blue level. + */ + setBackgroundColor(a: number, r: number, g:number, b:number): void; + + /** + * Checks whether or not the map background is transparent. + * @returns {boolean} Whether or not the map background is transparent. + */ + getIsBackgroundTransparent(): boolean; + + /** + * Sets a layer's visibility. + * @param {string} layerId The MapDotNet map layer ID. + * @param {boolean} isVisible Whether or not the layer should be visible. + */ + setLayerVisibility(layerId: string, isVisible: boolean): void; + + /** + * Gets a layer's visibility. + * @param {string} layerId The MapDotNet map layer ID. + * @returns {boolean} Whether or not the layer is visible. + */ + getLayerVisibility(layerId: string): boolean; + + /** + * Sets a layer's outline color and thickness. + * @param {string} layerId The MapDotNet map layer ID. + * @param {number} a Alpha level. + * @param {number} r Red level. + * @param {number} g Green level. + * @param {number} b Blue level. + * @param {number} thk Outline thickness in pixels. + */ + setLayerOutline(layerId: string, a: number, r: number, g: number, b: number, thk: number): void; + + /** + * Gets a layer's outline color and thickness. + * @param {string} layerId The MapDotNet map layer ID. + * @returns {object} JavaScript object of the form {color, thickness} + * where color is the CSS style string of the outline color and + * thickness is the outline thickness in pixels. + */ + getLayerOutline(layerId: string): { color: string; thickness: number; }; + + /** + * Sets a layer's fill color. + * @param {string} layerId The MapDotNet map layer ID. + * @param {number} a Alpha level. + * @param {number} r Red level. + * @param {number} g Green level. + * @param {number} b Blue level. + */ + setLayerFill(layerId: string, a: number, r: number, g: number, b: number): void; + + /** + * Sets a layer's fill color as a SQL expression. + * @param {string} layerId The MapDotNet map layer ID. + * @param {string} exp The SQL expression to select a row's fill color. + */ + setLayerFillAsExpression(layerId: string, exp: string): void; + + /** + * Gets a layer's fill color as a CSS style string or as a SQL expression. + * @param {string} layerId The MapDotNet map layer ID. + * @returns {string} Either the CSS style string or the SQL expression, + * according to how the layer's fill color was set. + */ + getLayerFill(layerId: string): string; + + /** + * Add or replace the where clause for a layer. The where clause + * is a SQL expression used to filter rows. + * @param {string} layerId The MapDotNet map layer ID. + * @param {string} where The desired SQL where expression. + * @param {boolean} [merge] Whether to merge the new where clause + * with the existing where clause using a SQL AND or to replace + * the existing where clause with the new one. Defaults to true (merge). + */ + setLayerWhere(layerId: string, where: string, merge: boolean): void; + + /** + * Sets a separator character for the layer where clause expression + * in the query string. This is set to ',' by default, which is + * consistent with SQL. + * @param {string} sep The desired seperator, which should be a + * single character. + */ + setLayerWhereSep(sep: string): void; + + /** + * Returns the current separator for the layer where clause in the + * query string. + * @returns {string} The current seperator. + */ + getLayerWhereSep(): string; + + /** + * Gets the current layer where clause. + * @param {string} layerId The MapDotNet map layer ID. + * @returns {string} The current where clause. If no where clause + * is in use, this will return an empty string. + */ + getLayerWhere(layerId: string): string; + + /** + * Gets a tag which is used to modify the request URIs to avoid + * browser caching + * @returns {string} The map's tag. + */ + getTag(): string; + + /** + * Sets the map's tag, which is used modify request URIs to avoid + * browser caching. + * @param {string} tag The desired tag. + */ + setTag(tag: string): void; + } + + /** + * Creates an instance of a descriptor for describing content from + * a MapDotNet REST feature service. + * @class descriptorMDNRestFeature + */ + export class descriptorMDNRestFeature { + constructor(mapId: string, layerId: string, options?: { + version?: string; + bleedRatio?: number; + fieldNames?: string[]; + clipToRenderBounds?: boolean; + simplifyEnabled?: boolean; + }); + + /** + * Gets the map ID. + * @returns {string} The map ID. + */ + getMapId(): string; + + /** + * Gets the layer's ID. + * @returns {string} The layer's ID. + */ + getLayerId(): string; + + /** + * Gets the version of the REST service. + * @returns {string} The REST service version. + */ + getVersion(): string; + + /** + * Sets the REST service version number. + * @param {string} v The version number to set. + */ + setVersion(v: string): void; + + /** + * Gets the bleed ratio. + * @returns {number} The current bleed ratio. + */ + getBleedRatio(): number; + + /** + * Sets the bleed ratio. Bleeds greater than 1.0 will fetch content + * beyond the edge of the tile extents (this is useful for point features). + * @param {number} br The desired bleed ratio, a number between 1.0 and 2.0. + */ + setBleedRatio(br: number): void; + + /** + * Gets the optional field names to query. This attribute data may + * be used in dynamic client-side rendering. + * @returns {string[]} An array of field names as strings. + */ + getFieldNames(): string[]; + + /** + * Sets the optional field names to query. This attribute data may be used in + * dynamic client-side rendering. + * @param {string} names - array of strings for each field to query + */ + setFieldNames(names: string[]): void; + + /** + * Checks the flag whether to clip geometry fetched at the bounds + * of the request. + * @returns {boolean} The value of the flag. + */ + getClipToRenderBounds(): boolean; + + /** + * Sets the flag whether to clip geometry fetched at the bounds + * of the request. This can greatly improve performance with large + * complex geometries. Only supported when back-end store is SQL + * 2008/2012 or PostGIS. + * @param {boolean} flag Whether or not to clip geometries fetched + * at the bounds of the request. + */ + setClipToRenderBounds(flag: boolean): void; + + /** + * Checks the flag whether to simplify paths based on the units per + * pixel for the quad tile being requested. + * @returns {boolean} The value of the flag. + */ + getSimplifyEnabled(): boolean; + + /** + * Sets the flag whether to simplify paths based on the units per + * pixel for the quad tile being requested. + * @param {boolean} flag Whether or not to simply paths based on + * the units per pixel. + */ + setSimplifyEnabled(flag: boolean): void; + + /** + * Sets the action to perform on descriptor change. + * @param {function} action Function with signature action(). + */ + setNotifyDescriptorChangeAction(action: () => void): void; + } + + /** + * This is a generic tile requestor suitable for several third-party + * tile servers. These include open street map, map quest, cloudmade, + * Nokia, etc. + * @class requestorOpen + */ + export class requestorOpen extends requestor { + constructor(endpoint: string, subdomains: string[], options?: { + dataFormat?: string; + timeoutMs?: number; + maxAvailableZoomLevel?: number; + }); + } + + /** + * This is a requestor for local collections of data. These local collections may + * originate from inlined code or from datasources other than a MapDotNet REST + * feature service. + * @class requestorLocal + */ + export class requestorLocal extends requestor { + constructor(options?: { + dataFormat?: string; + timeoutMs?: number; + maxAvailableZoomLevel?: number; + data: {}[]; + }); + + /** + * Gets the unparsed source data. + * @returns {object} Array of source data objects. + */ + getSource(): {}[]; + + /** + * Sets source data. + * @param {object} data An array of JavaScript objects to use as + * the requestor source data. + */ + setSource(data: {}[]): void; + + /** + * Returns your source data parsed into theformat { Shapes: [], + * Values: [], Bounds: [] } This may be useful for doing client-side + * queries on the local data where all of the WKT has been parsed + * into points and geometry. There is also a bounds collection to + * do a quick spatial check for complex polygons. + * @returns {object} Parsed data object in the form {Shapes, Values, Bounds}. + */ + getParsedData(): { + Shapes: any[]; + Values: any[]; + Bounds: envelope[]; + }; + } + + /** + * Local descriptor object for describing source data when the source + * data is fecthed by a local requestor. + * @class descriptorLocal + */ + export class descriptorLocal { + constructor(options: { + valueFieldNames: string[]; + geometryFieldName: string; + bleedRatio?: number; + }); + } + } + + interface pointObject { + x: number; + y: number; + } + + interface envObject { + + /** + * @returns {number} minX as integer + */ + minX: number; + + /** + * @returns {number} minY coord as integer + */ + minY: number; + + /** + * @returns {number} maxX coord as integer + */ + maxX: number; + + /** + * @returns {number} maxY coord as integer + */ + maxY: number; + } + + interface mapsjsWidget { + + /** + * Gets the center of the map in spherical mercator. Use + * sphericalMercator.deprojectToLatLon static function to convert to a lat/lon. + * @return {point} A point map center + */ + getMapCenter(): point; + + /** + * Sets the center of the map in spherical mercator. Use + * sphericalMercator.projectFromLatLon static function to convert from a lat/lon. + * @param {point} center The map center as a point + */ + setMapCenter(center: point): void; + + /** + * Same as setMapCenter except will animate from current map center to the + * specified location + * @param {point} center The map center as a point. + * @param {number} [durationMs] Duration in miliseconds. + * @param {function} [completeAction] Callback to perform on animaton complete. + */ + setMapCenterAnimate(center: point, durationMs?: number, completeAction?: () => void): void; + + /** + * Sets the map center to the current geolocation if supported. The map is + * animated to the new location. + * @param {number} [durationMs] Duration in miliseconds. + * @param {function} [completeAction] Callback to perform on animaton complete. + */ + setMapCenterToGeolocationAnimate(durationMs?: number, completeAction?: () => void): void; + + /** + * Gets the current zoom level. + * @returns {number} The current zoom level. + */ + getZoomLevel(): number; + + /** + * Sets the current zoom level. + * @param {number} z1 The desired zoom level. + */ + setZoomLevel(zl: number): void; + + /** + * Sets the minimum zoom level for the map. + * @param {number} zl Desired minimum zoom level. + */ + setMinZoomLevel(zl: number): void; + + /** + * Sets the maximum zoom level for the map. + * @param {number} z1 The desired maximum zoom level. + */ + setMaxZoomLevel(zl: number): void; + + /** + * Animates the map from the current zoom level to the given zoom level. + * @param {number} zl The desired zoom level. + * @param {number} [durationMs] The duration in miliseconds. + * @param {function} [completeAction] Function to call when the animation + * completes with signature completeAction(). + */ + setZoomLevelAnimate(zl: number, durationMs?: number, completeAction?: () => void): void; + + /** + * Changes the current zoom level. + * @param {number} delta Change to be added to the current zoom level. + */ + zoomDelta(delta: number): void; + + /** + * Animates a change to the current zoom level. + * @param {number} delta Change to be added to the current zoom level. + * @param {number} [durationMs] Duration in miliseconds. + */ + zoomDeltaAnimate(delta: number, durationMs?: number): void; + + /** + * Animates parabolically from the current map center and zoom level + * to the given map center and zoom level. + * @param {point} center Desired map center as a point. + * @param {number} zl Desired zoom level. + * @param {number} [durationMs] Animation duration in miliseconds. + * @param {function} [completeAction] Function to call after the animation + * completes with signature completeAction(). + */ + flyTo(center: point, zl: number, durationMs?: number, completeAction?: () => void): void; + + /** + * Gets the current map extents in spherical mercator units. + * @return {envelope} envelope The current map extents. + */ + getMapExtents(): envelope; + + /** + * Gets the current map units per pixel. + * @returns {number} Map units (meters) per pixel. + */ + getMapUnitsPerPixel(): number; + + /** + * Gets the map extents' width and height in pixels. + * @returns {object} JavaScript object of the form {w, h} where w is + * the current extents' width in pixels and h is the current extents' + * height in pixels. + */ + getViewExtentsInPix(): { w: number; h: number; }; + + /** + * Gets the current projected map scale. This is the ratio of units on + * the screen to map units depicted. + * @returns {number} Ratio of screen units to map units. + */ + getProjectedMapScale(): number; + + /** + * Gets the current actual map scale. This is the ratio of units on + * the screen to actual units on the earth's surface at the latitude + * of the current map center. + * @returns {number} The ratio of screen units to actual meters. + */ + getActualMapScale(): number; + + /** + * Gets the best fit zoom level based on the supplied map extents for + * the current display extents in pixels. + * @param {envelope} extentsNew New map extents to fit. + * @returns {number} The zoom level which best fits the extents. + */ + getBestFitZoomLevelByExtents(extentsNew: envelope): number; + + /** + * Forces the map to redraw the currently loaded tile and geometry + * content. You should not have to call this as redraws are automatically + * handled during programatic state changes. This would be for edge cases + * where the developer is affecting internal state in an undocumented way. + */ + redraw(): void; + + /** + * Updates the map to the size of its container. This updates internal + * parameters for computing map extents and handling the amount of tile + * content to download. This is handled automatically if the browser + * window is resized. But if you are sizing the map programatically + * (e.g. resizable panel or slider) then call this after the parent + * container has resized. + */ + resize(): void; + + /** + * Pushes a supplied tile layer onto the top of the display stack. + * @param {tile.layer} tl The desired tile layer. + */ + pushTileLayer(tl: tile.layer): void; + + /** + * Removes a tile layer off the top of the display stack + * @returns {tile.layer} The removed tile layer. + */ + popTileLayer(): tile.layer; + + /** + * Removes a tile layer off the display stack by reference + * @param {tile.layer} tl - a tile layer + */ + removeTileLayer(tl: tile.layer): void; + + /** + * Removes all tile layers off the display stack + */ + removeAllTileLayers(): void; + + /** + * Gets the current number of tile layers in the display stack. + * @returns {number} The number of tile layers in the display stack. + */ + getTileLayerCount(): number; + + /** + * Gets a tile layer from the display stack by its key. + * @param {string} key The desired tile layer's key. + * @returns {tile.layer} The tile layer associated with the key, or null + * if no tile layer is associated with the key. + */ + getTileLayer(key: string): tile.layer; + + /** + * Gets a point in map units from supplied coordinates pixel units + * with respect to the currently displayed extents. + * @param {number} x The x coordinate in pixels. + * @param {number} y The y coordinate in pixels. + * @returns {point} The generated point in map units. + */ + computeMapPointFromPixelLocation(x: number, y: number): point; + + /** + * Flags whether or not map extent changes can occur through gestures + * like mouse or touch drag, mouse wheel, or pinch zoom. + * @param {boolean} flag Whether or not gestures should affect map + * extent changes. + */ + setSuspendMapExtentChangesByGestures(flag: boolean): void; + + /** + * Sets the z-order of drawn content in relation to the gesture capture + * panel. The default behavior (false) is to have fixed content and + * geometry underneath the gesture panel in the DOM. If false, all + * pointer events are handled by the gesture capture panel and + * optionally parents of the map control. If true, drawn content will + * receive pointer events first and will block gestures to the map. If + * true, digitizing will not function and polygons will block map + * navigation. In some scenarios you may want to set this to true if you + * are placing fixed content (such as point features) on the map and + * need to handle gestures on the placed content. You can call this + * function at any time to change the order. + * @param {boolean} flag Whether or not the fixed content layer should + * reside above the gesture layer. + */ + setDrawnContentZorderToTop(flag: boolean): void; + + /** + * Add a fixed element to the content area which resides at a z-level + * above tiled map content. These elements do not scale with the map + * scale. This is used to place markers or callouts on the map + * @param {HTMLElement} element Any html that can be added to the DOM. + * @param {number} mapUnitsX The x coordinate of the insertion point in map units. + * @param {number} mapUnitsY The y coordinate of the insertion point in map units. + * @param {function} [addAction] Callback function called after the + * DOM element has been placed with signature addAction(element). + * @param {object} dragOptions JavaScript object of the form {dragEnabled, + * useElementInsteadOfNewGestureOverlay, downAction, moveAction, upAction, + * wheelAction } where dragEnabled flags whether dragging should be + * enabled on the element, and downAction, moveAction, upAction, and + * wheelAction are callback functions invoked on mousedown, mousemove, + * mouseup, and scroll events respectively. + */ + addFixedContentElement( + element: HTMLElement, + mapUnitsX: number, + mapUnitsY: number, + addAction?: (ele: HTMLElement) => void, + dragOptions?: { + dragEnabled: boolean; + useElementInsteadOfNewGestureOverlay: boolean; + downAction?: (downPoint: point) => any; + moveAction?: (movePoint: point) => void; + upAction?: (upPoint: point) => void; + wheelAction?: (delta: number) => void; + } + ): void; + + /** + * Move an existing fixed content element. + * @param {HTMLElement} element The existing DOM element to move. + * @param {number} mapUnitsX The new x coordinate in map units. + * @param {number} mapUnitsY The new y coordinate in map units. + */ + moveFixedContentElement(element: HTMLElement, mapUnitsX: number, mapUnitsY: number): void; + + /** + * Removes a fixed content element. + * @param {HTMLElement} element The DOM element to remove. Note: This + * must be the same element added by addFixedContentElement. + */ + removeFixedContentElement(element: HTMLElement): void; + + /** + * Add a styled path geometry to the content area which resides at a z-level + * above tiled map content. The geometry is converted to SVG and added to the + * content area DOM. If an attempt to add a geometry is made with the same + * key, the geometry is swapped out. You must remove using removePathGeometry + * for resource cleanup. + * @param {styleGeometry} styledGeom THe styledGeometry to render. + * @param {string} key String used to tie a geometry to its SVG + * rendering in the DOM. + * @returns {element} The SVG element which was added to the DOM. + */ + addPathGeometry(styledGeom: styledGeometry, key: string): void; + + /** + * Updates an existing path geometry to reflect a style change. + * @param {geometryStyle} styleNew The new geometryStyle. + * @param {string} key The key of the geometry to receive the new style. + */ + updatePathGeometryStyle(styleNew: geometryStyle, key: string): void; + + /** + * Removes a styledGeometry from display. + * @param {string} key The key of the geometry to remove. + */ + removePathGeometry(key: string): void; + + /** + * Initiates digitization on the map control. This creates a new + * geometry and adds verticies to the geometry accord to mouse + * click locations. + * @param {object} options JavaScript object of the form { key, + * shapeType, geometryStyle, nodeTapAndHoldAction, nodeMoveAction, + * shapeChangeAction, envelopeEndAction, supressNodeAdd, leavePath } + * where key is a a string associated with this geometry, shapeType + * is the type of shape this geometry is, one of 'point', 'path', or + * 'polygon', geometryStyle is a geometryStyle which should be applied + * to the digitized geometry, nodeTapAndHoldAction is a callback invoked + * when any point in the geometry is clicked and held and has the + * signature nodeTapAndHoldAction(setIdx, idx), nodeMoveAction is a + * callback invoked after any node is dragged to a new location and + * has signature nodeMoveAction(x, y, actionType), shapeChangeAction + * is a callback that is invoked after the geometry shape changes and, + * has signature shapeChangeAction(), envelopeEndAction is a callback + * invoked after an envelope is created and has signature envelopeEndAction(envelope), + * and leavePath is a flag that indicates whether the digitized shape + * should be left on the map after digitization is complete. + */ + beginDigitize(options: { + key?: string; + shapeType: string; + geometryStyle?: geometryStyle; + nodeTapAndHoldAction?: (setIdx: number, idx: number) => boolean; + nodeMoveAction?: (x: number, y: number, actionType: string) => any; + shapeChangeAction?: () => void; + envelopeEndAction?: (env: envelope) => void; + suppressNodeAdd?: boolean; + leavePath?: boolean; + }): void; + endDigitize(): void; + + /** + * Gets a snapshot copy of the currently digitizing path. + * @returns {geometry} The currently digitizing path. + */ + getDigitizeSnapshot(): geometry; + + /** + * Forces additional digitized points to be pushed to a new set of the + * currently digitizing geometry. + */ + pushSetOnDigitizePath(): void; + + /** + * Removes the last set from the currently digitizing path. + * @return {number[]} The last set from the currently digitizing path + * in the form [xn,yn]. + */ + popSetFromDigitizePath(): number[]; + + /** + * Programmatically delete a node from the currently digitizing path. + * @param {number} setIdx The index of the set from which to remove the node. + * @param {number} nodeIdx The index of the node to remove. + */ + deleteNodeOnDigitizePath(setIdx: number, nodeIdx: number): void; + + /** + * Determines whether a shape is currently being digitized. + * @returns {boolean} Whether or not a shape is being digitized. + */ + isDigitizingEnabled(): boolean; + + /** + * Set the function called when the map extents have stopped changing + * (e.g. after an animated pan or zoom). + * @param {function} action The function to call when the extents + * finish changing with signature action(object) where object is of + * the form { centerX, centerY, centerLat, centerLon, zoomLevel, mapScale, + * mapScaleProjected, mapUnitsPerPixel, extents }. + */ + setExtentChangeCompleteAction(action: (vals: {}) => void): void; + + /** + * Set the function called when map content (map tiles and fixed elements) are + * re-positioned in the DOM. This is done automatically as the map is panned + * beyond existing content and zoomed to a new level requiring content. + * @param {function} action The function to call when the map content + * completes repositioning with signature action(object) where object + * is of the form { centerX, centerY, zoomLevel, mapUnitsPerPixel }. + */ + setContentRepositionAction(action: (vals: {}) => void): void; + + /** + * Sets function called when map is clicked or tapped. + * @param {function} action The function to call on mouse click or tap + * with signature action(point). + */ + setPointerClickAction(action: (pt: point) => void): void; + + /** + * Sets function called when the map pointer hovers over the map. + * @param {function} action The function to call on mouse hover with + * signature action(point). + */ + setPointerHoverAction(action: (pt: point) => void): void; + + /** + * Sets the margin around the map in pixels for extra content fetched so that tile + * rebuilding of the display is minimized. This is an advanced property and does not + * generally need to be adjusted. The default is 128 pixels, or half the width + * of a tile. This should be increased for maps which are very large in pixels + * or where panning is constant. This should be decreased for very small maps, + * such as on mobile devices, or where panning is minimal. + * @param {number} cem The content extent margin in pixels. + */ + setContentExtentsMarginInPixels(cem: number): void; + + /** + * Sets the background color of the map using a css color string + * @param {number} b- a css color string + */ + setBackground(b: string): void; + } +} + +interface JQuery { + + rimMap(): JQuery; + rimMap(command: any, param?: any, param2?: any, param3?: any, param4?: any, param5?: any): JQuery; + getMapsjs(): any; +} diff --git a/mapsjs/mapsjs.d.ts.tscparams b/mapsjs/mapsjs.d.ts.tscparams new file mode 100644 index 000000000..3cc762b55 --- /dev/null +++ b/mapsjs/mapsjs.d.ts.tscparams @@ -0,0 +1 @@ +"" \ No newline at end of file