@hpcc-js/map 2.79.3 → 2.79.5

package/src/Graticule.ts

@@ -1,90 +1,90 @@
-import { geoGraticule as d3GeoGraticule } from "d3-geo";
-import { select as d3Select } from "d3-selection";
-import { Layer } from "./Layer";
-
-import "../src/Graticule.css";
-
-export class Graticule extends Layer {
-    _dataMap = {};
-    _path: any = d3Select(null);
-    _graticule;
-    _graticulePath;
-    _graticuleOutlinePath;
-    _prevProjection;
-
-    constructor() {
-        super();
-    }
-
-    layerEnter(base, svgElement, domElement) {
-        Layer.prototype.layerEnter.apply(this, arguments);
-
-        this._graticule = d3GeoGraticule();
-        this._graticulePath = svgElement.append("path")
-            .datum(this._graticule)
-            .attr("class", "graticule")
-            .attr("vector-effect", "non-scaling-stroke")
-            ;
-        this._graticuleOutlinePath = svgElement.append("path")
-            .datum(this._graticule.outline)
-            .attr("class", "graticuleOutline")
-            .attr("vector-effect", "non-scaling-stroke")
-            ;
-    }
-
-    layerUpdate(base) {
-        if (!this.visible()) {
-            this._graticulePath.attr("d", "");
-            this._graticuleOutlinePath.attr("d", "");
-            delete this._prevProjection;
-            return;
-        }
-
-        if (this._prevProjection !== base.projection()) {
-            this._graticulePath
-                .attr("d", base._d3GeoPath)
-                ;
-            this._graticuleOutlinePath
-                .attr("d", base._d3GeoPath)
-                ;
-            this._prevProjection = base.projection();
-        }
-        this._graticulePath
-            .style("stroke", this.meshColor())
-            ;
-        this._graticuleOutlinePath
-            .style("stroke", this.meshColor())
-            ;
-    }
-
-    layerExit(base) {
-        delete this._prevProjection;
-    }
-
-    /*
-        layerZoomed(base) {
-            this._graticulePath
-                .style("opacity", this.opacity())
-                .attr("transform", "translate(" + base._zoom.translate() + ")scale(" + base._zoom.scale() + ")")
-                .style("stroke-width", this.meshStrokeWidth() / base._zoom.scale() + "px")
-                ;
-            this._graticuleOutlinePath
-                .style("opacity", this.opacity())
-                .attr("transform", "translate(" + base._zoom.translate() + ")scale(" + base._zoom.scale() + ")")
-                .style("stroke-width", this.meshStrokeWidth() / base._zoom.scale() + "px")
-                ;
-        }
-    */
-    opacity: { (): number; (_: number): Graticule };
-    opacity_exists: () => boolean;
-    meshColor: { (): string; (_: string): Graticule };
-    meshColor_exists: () => boolean;
-    meshStrokeWidth: { (): number; (_: number): Graticule };
-    meshStrokeWidth_exists: () => boolean;
-}
-Graticule.prototype._class += " map_Graticule";
-
-Graticule.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
-
-Graticule.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
-Graticule.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");
+import { geoGraticule as d3GeoGraticule } from "d3-geo";
+import { select as d3Select } from "d3-selection";
+import { Layer } from "./Layer";
+
+import "../src/Graticule.css";
+
+export class Graticule extends Layer {
+    _dataMap = {};
+    _path: any = d3Select(null);
+    _graticule;
+    _graticulePath;
+    _graticuleOutlinePath;
+    _prevProjection;
+
+    constructor() {
+        super();
+    }
+
+    layerEnter(base, svgElement, domElement) {
+        Layer.prototype.layerEnter.apply(this, arguments);
+
+        this._graticule = d3GeoGraticule();
+        this._graticulePath = svgElement.append("path")
+            .datum(this._graticule)
+            .attr("class", "graticule")
+            .attr("vector-effect", "non-scaling-stroke")
+            ;
+        this._graticuleOutlinePath = svgElement.append("path")
+            .datum(this._graticule.outline)
+            .attr("class", "graticuleOutline")
+            .attr("vector-effect", "non-scaling-stroke")
+            ;
+    }
+
+    layerUpdate(base) {
+        if (!this.visible()) {
+            this._graticulePath.attr("d", "");
+            this._graticuleOutlinePath.attr("d", "");
+            delete this._prevProjection;
+            return;
+        }
+
+        if (this._prevProjection !== base.projection()) {
+            this._graticulePath
+                .attr("d", base._d3GeoPath)
+                ;
+            this._graticuleOutlinePath
+                .attr("d", base._d3GeoPath)
+                ;
+            this._prevProjection = base.projection();
+        }
+        this._graticulePath
+            .style("stroke", this.meshColor())
+            ;
+        this._graticuleOutlinePath
+            .style("stroke", this.meshColor())
+            ;
+    }
+
+    layerExit(base) {
+        delete this._prevProjection;
+    }
+
+    /*
+        layerZoomed(base) {
+            this._graticulePath
+                .style("opacity", this.opacity())
+                .attr("transform", "translate(" + base._zoom.translate() + ")scale(" + base._zoom.scale() + ")")
+                .style("stroke-width", this.meshStrokeWidth() / base._zoom.scale() + "px")
+                ;
+            this._graticuleOutlinePath
+                .style("opacity", this.opacity())
+                .attr("transform", "translate(" + base._zoom.translate() + ")scale(" + base._zoom.scale() + ")")
+                .style("stroke-width", this.meshStrokeWidth() / base._zoom.scale() + "px")
+                ;
+        }
+    */
+    opacity: { (): number; (_: number): Graticule };
+    opacity_exists: () => boolean;
+    meshColor: { (): string; (_: string): Graticule };
+    meshColor_exists: () => boolean;
+    meshStrokeWidth: { (): number; (_: number): Graticule };
+    meshStrokeWidth_exists: () => boolean;
+}
+Graticule.prototype._class += " map_Graticule";
+
+Graticule.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
+
+Graticule.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
+Graticule.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");

package/src/Heat.css

@@ -1,3 +1,3 @@
-.map_Heat canvas {
-  pointer-events: none;
+.map_Heat canvas {
+  pointer-events: none;
 }

package/src/Heat.ts

@@ -1,82 +1,82 @@
-import { HeatMap } from "@hpcc-js/other";
-import { Layer } from "./Layer";
-
-import "../src/Heat.css";
-
-export class Heat extends Layer {
-    _heatTransform;
-    heat;
-    _prevProjection;
-
-    constructor() {
-        super();
-    }
-
-    layerEnter(base, svgElement, domElement) {
-        Layer.prototype.layerEnter.apply(this, arguments);
-        this._parentOverlay.style("pointer-events", "none");
-        this._heatTransform = domElement
-            .style("pointer-events", "none")
-            .append("div")
-            .attr("class", this.classID())
-            .style("width", base.width() + "px")
-            .style("height", base.height() + "px")
-            ;
-        this.heat = new HeatMap()
-            .target(this._heatTransform.node())
-            ;
-    }
-
-    layerUpdate(base) {
-        Layer.prototype.layerUpdate.apply(this, arguments);
-
-        this._heatTransform
-            .style("opacity", this.opacity())
-            .style("width", base.width() + "px")
-            .style("height", base.height() + "px")
-            ;
-        this.heat.resize(base.size());
-        this.layerZoomed(base);
-    }
-
-    layerExit(base) {
-        delete this._prevProjection;
-        this.heat.target(null);
-        delete this.heat;
-    }
-
-    layerZoomed(base) {
-        Layer.prototype.layerZoomed.apply(this, arguments);
-        const latField = this._db.fieldByLabel(this.latColumn());
-        const longField = this._db.fieldByLabel(this.longColumn());
-        this.heat
-            .columns(this.columns())
-            .data(this.visible() ? this.data().map(function (row) {
-                const lat = latField ? row[latField.idx] : row[0];
-                const long = longField ? row[longField.idx] : row[1];
-                const transform = base.zoomTranslate();
-                const pos = base.project(lat, long);
-                const scale = base.zoomScale();
-                pos[0] *= scale;
-                pos[1] *= scale;
-                return [transform[0] + pos[0], transform[1] + pos[1], row[4] || 0.5];
-            }) : [])
-            .render()
-            ;
-    }
-
-    latColumn: { (): string; (_: string): Heat };
-    latColumn_exists: () => boolean;
-    longColumn: { (): string; (_: string): Heat };
-    longColumn_exists: () => boolean;
-    opacity: { (): number; (_: number): Heat };
-    opacity_exists: () => boolean;
-}
-Heat.prototype._class += " map_Heat";
-
-Heat.prototype.publish("latColumn", null, "set", "Latitude column", function () { return this.columns(); }, { optional: true });
-Heat.prototype.publish("longColumn", null, "set", "Longitude column", function () { return this.columns(); }, { optional: true });
-Heat.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
-
-// Heat.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
-// Heat.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");
+import { HeatMap } from "@hpcc-js/other";
+import { Layer } from "./Layer";
+
+import "../src/Heat.css";
+
+export class Heat extends Layer {
+    _heatTransform;
+    heat;
+    _prevProjection;
+
+    constructor() {
+        super();
+    }
+
+    layerEnter(base, svgElement, domElement) {
+        Layer.prototype.layerEnter.apply(this, arguments);
+        this._parentOverlay.style("pointer-events", "none");
+        this._heatTransform = domElement
+            .style("pointer-events", "none")
+            .append("div")
+            .attr("class", this.classID())
+            .style("width", base.width() + "px")
+            .style("height", base.height() + "px")
+            ;
+        this.heat = new HeatMap()
+            .target(this._heatTransform.node())
+            ;
+    }
+
+    layerUpdate(base) {
+        Layer.prototype.layerUpdate.apply(this, arguments);
+
+        this._heatTransform
+            .style("opacity", this.opacity())
+            .style("width", base.width() + "px")
+            .style("height", base.height() + "px")
+            ;
+        this.heat.resize(base.size());
+        this.layerZoomed(base);
+    }
+
+    layerExit(base) {
+        delete this._prevProjection;
+        this.heat.target(null);
+        delete this.heat;
+    }
+
+    layerZoomed(base) {
+        Layer.prototype.layerZoomed.apply(this, arguments);
+        const latField = this._db.fieldByLabel(this.latColumn());
+        const longField = this._db.fieldByLabel(this.longColumn());
+        this.heat
+            .columns(this.columns())
+            .data(this.visible() ? this.data().map(function (row) {
+                const lat = latField ? row[latField.idx] : row[0];
+                const long = longField ? row[longField.idx] : row[1];
+                const transform = base.zoomTranslate();
+                const pos = base.project(lat, long);
+                const scale = base.zoomScale();
+                pos[0] *= scale;
+                pos[1] *= scale;
+                return [transform[0] + pos[0], transform[1] + pos[1], row[4] || 0.5];
+            }) : [])
+            .render()
+            ;
+    }
+
+    latColumn: { (): string; (_: string): Heat };
+    latColumn_exists: () => boolean;
+    longColumn: { (): string; (_: string): Heat };
+    longColumn_exists: () => boolean;
+    opacity: { (): number; (_: number): Heat };
+    opacity_exists: () => boolean;
+}
+Heat.prototype._class += " map_Heat";
+
+Heat.prototype.publish("latColumn", null, "set", "Latitude column", function () { return this.columns(); }, { optional: true });
+Heat.prototype.publish("longColumn", null, "set", "Longitude column", function () { return this.columns(); }, { optional: true });
+Heat.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
+
+// Heat.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
+// Heat.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");

package/src/IChoropleth.ts

@@ -1,8 +1,8 @@
-import { Palette } from "@hpcc-js/common";
-export function IChoropleth() {
-}
-IChoropleth.prototype._palette = Palette.rainbow("default");
-
-//  Events  ---
-IChoropleth.prototype.click = function (row, column, selected) {
-};
+import { Palette } from "@hpcc-js/common";
+export function IChoropleth() {
+}
+IChoropleth.prototype._palette = Palette.rainbow("default");
+
+//  Events  ---
+IChoropleth.prototype.click = function (row, column, selected) {
+};

package/src/Layer.ts

@@ -1,90 +1,90 @@
-import { ITooltip } from "@hpcc-js/api";
-import { Layered } from "./Layered";
-
-export class Layer extends Layered {
-    _svgElement;
-    _domElement;
-    _topoJsonPromise;
-
-    constructor() {
-        super();
-        ITooltip.call(this);
-    }
-
-    //  Disable Glow For Layers ---
-    svgGlowID(): string {
-        return "";
-    }
-
-    layerEnter(base, svgElement, domElement) {
-        this._parentOverlay = base._parentOverlay;
-    }
-
-    enter(domNode, element) {
-        super.enter(domNode, element);
-        this._svgElement = this._layersTarget.append("g");
-        this._domElement = this._parentOverlay.append("div");
-        this.layerEnter(this, this._svgElement, this._domElement);
-    }
-
-    layerUpdate(base, forcePath?) {
-    }
-
-    update(domNode, element) {
-        super.update(domNode, element);
-        this.layerUpdate(this);
-    }
-
-    onZoomed() {
-        super.onZoomed();
-        this.layerUpdate(this);
-    }
-
-    layerExit(base) {
-    }
-
-    exit(domNode, element) {
-        this.layerExit(this);
-        this._svgElement.remove();
-        this._domElement.remove();
-        super.exit(domNode, element);
-    }
-
-    layerPreRender() {
-        return Promise.resolve();
-    }
-
-    render(callback?: (w: this) => void): this {
-        const context = this;
-        const args = arguments;
-        this.layerPreRender().then(function () {
-            Layered.prototype.render.apply(context, args);
-        });
-        return this;
-    }
-
-    layerZoomed(base) {
-    }
-
-    //  ITooltip  ---
-    tooltip: any;
-
-    tooltipHTML: (_: any) => any;
-    tooltipFormat: (opts: any) => string;
-    tooltipStyle: { (): string; (_: string): ITooltip };
-    tooltipStyle_exists: () => boolean;
-    tooltipValueFormat: { (): string; (_: string): ITooltip };
-    tooltipValueFormat_exists: () => boolean;
-    tooltipSeriesColor: { (): string; (_: string): ITooltip };
-    tooltipSeriesColor_exists: () => boolean;
-    tooltipLabelColor: { (): string; (_: string): ITooltip };
-    tooltipLabelColor_exists: () => boolean;
-    tooltipValueColor: { (): string; (_: string): ITooltip };
-    tooltipValueColor_exists: () => boolean;
-    tooltipTick: { (): boolean; (_: boolean): ITooltip };
-    tooltipTick_exists: () => boolean;
-    tooltipOffset: { (): number; (_: number): ITooltip };
-    tooltipOffset_exists: () => boolean;
-}
-Layer.prototype._class += " map_Layer";
-Layer.prototype.implements(ITooltip.prototype);
+import { ITooltip } from "@hpcc-js/api";
+import { Layered } from "./Layered";
+
+export class Layer extends Layered {
+    _svgElement;
+    _domElement;
+    _topoJsonPromise;
+
+    constructor() {
+        super();
+        ITooltip.call(this);
+    }
+
+    //  Disable Glow For Layers ---
+    svgGlowID(): string {
+        return "";
+    }
+
+    layerEnter(base, svgElement, domElement) {
+        this._parentOverlay = base._parentOverlay;
+    }
+
+    enter(domNode, element) {
+        super.enter(domNode, element);
+        this._svgElement = this._layersTarget.append("g");
+        this._domElement = this._parentOverlay.append("div");
+        this.layerEnter(this, this._svgElement, this._domElement);
+    }
+
+    layerUpdate(base, forcePath?) {
+    }
+
+    update(domNode, element) {
+        super.update(domNode, element);
+        this.layerUpdate(this);
+    }
+
+    onZoomed() {
+        super.onZoomed();
+        this.layerUpdate(this);
+    }
+
+    layerExit(base) {
+    }
+
+    exit(domNode, element) {
+        this.layerExit(this);
+        this._svgElement.remove();
+        this._domElement.remove();
+        super.exit(domNode, element);
+    }
+
+    layerPreRender() {
+        return Promise.resolve();
+    }
+
+    render(callback?: (w: this) => void): this {
+        const context = this;
+        const args = arguments;
+        this.layerPreRender().then(function () {
+            Layered.prototype.render.apply(context, args);
+        });
+        return this;
+    }
+
+    layerZoomed(base) {
+    }
+
+    //  ITooltip  ---
+    tooltip: any;
+
+    tooltipHTML: (_: any) => any;
+    tooltipFormat: (opts: any) => string;
+    tooltipStyle: { (): string; (_: string): ITooltip };
+    tooltipStyle_exists: () => boolean;
+    tooltipValueFormat: { (): string; (_: string): ITooltip };
+    tooltipValueFormat_exists: () => boolean;
+    tooltipSeriesColor: { (): string; (_: string): ITooltip };
+    tooltipSeriesColor_exists: () => boolean;
+    tooltipLabelColor: { (): string; (_: string): ITooltip };
+    tooltipLabelColor_exists: () => boolean;
+    tooltipValueColor: { (): string; (_: string): ITooltip };
+    tooltipValueColor_exists: () => boolean;
+    tooltipTick: { (): boolean; (_: boolean): ITooltip };
+    tooltipTick_exists: () => boolean;
+    tooltipOffset: { (): number; (_: number): ITooltip };
+    tooltipOffset_exists: () => boolean;
+}
+Layer.prototype._class += " map_Layer";
+Layer.prototype.implements(ITooltip.prototype);

package/src/Layered.css

@@ -1,19 +1,19 @@
-.map_Layered .background {
-    fill: none;
-}
-
-.map_Layered .raster image {
-    fill: #B5D0D0
-}
-
-.map_Layered .vector {
-  fill: none;
-  stroke: navy;
-  stroke-linejoin: round;
-}
-
-.map_Layered .hash path {
-  fill: none;
-  stroke: red;
-  stroke-linejoin: round;
-}
+.map_Layered .background {
+    fill: none;
+}
+
+.map_Layered .raster image {
+    fill: #B5D0D0
+}
+
+.map_Layered .vector {
+  fill: none;
+  stroke: navy;
+  stroke-linejoin: round;
+}
+
+.map_Layered .hash path {
+  fill: none;
+  stroke: red;
+  stroke-linejoin: round;
+}