@hpcc-js/map 2.79.2 → 2.79.3

package/src/GeoHash.ts

@@ -1,125 +1,125 @@
-import { Palette, Utility as CommonUtility } from "@hpcc-js/common";
-import { select as d3Select } from "d3-selection";
-import { Layer } from "./Layer";
-import * as Utility from "./Utility";
-
-import "../src/GeoHash.css";
-
-export class GeoHash extends Layer {
-    _palette;
-    _dataMinWeight;
-    _dataMaxWeight;
-    geohash;
-    _geoHashTransform;
-    _selection;
-    geoHashPaths;
-
-    constructor() {
-        super();
-    }
-
-    data(_?) {
-        const retVal = Layer.prototype.data.apply(this, arguments);
-        if (arguments.length) {
-            this._dataMinWeight = null;
-            this._dataMaxWeight = null;
-
-            this.data().forEach(function (item) {
-                if (!this._dataMinWeight || item[1] < this._dataMinWeight) {
-                    this._dataMinWeight = item[1];
-                }
-                if (!this._dataMaxWeight || item[1] > this._dataMaxWeight) {
-                    this._dataMaxWeight = item[1];
-                }
-            }, this);
-        }
-        return retVal;
-    }
-
-    layerEnter(base, svgElement, domElement) {
-        Layer.prototype.layerEnter.apply(this, arguments);
-
-        this.geohash = new Utility.Geohash();
-        this._geoHashTransform = svgElement
-            .append("g")
-            .attr("class", "map_GeoHash")
-            ;
-        this._selection = new CommonUtility.SimpleSelection(this, this._geoHashTransform);
-        this.geoHashPaths = d3Select(null);
-    }
-
-    layerUpdate(base) {
-        Layer.prototype.layerUpdate.apply(this, arguments);
-
-        this._palette = this._palette.switch(this.paletteID());
-        if (this.useClonedPalette()) {
-            this._palette = this._palette.cloneNotExists(this.paletteID() + "_" + this.id());
-        }
-
-        this._geoHashTransform.style("opacity", this.opacity());
-
-        this.geoHashPaths = this._geoHashTransform.selectAll(".data").data(this.visible() ? this.data() : [], function (d) { return d[0]; });
-        const context = this;
-        this.geoHashPaths.enter().append("path")
-            .attr("class", "data")
-            .call(this._selection.enter.bind(this._selection))
-            .on("click", function (d) {
-                context.click(context.rowToObj(d), "weight", context._selection.selected(this));
-            })
-            .on("dblclick", function (d) {
-                context.dblclick(context.rowToObj(d), "weight", context._selection.selected(this));
-            })
-            .merge(this.geoHashPaths)
-            .attr("d", function (d) {
-                const pos = context.geohash.bounds(d[0]);
-                const route = {
-                    type: "LineString",
-                    coordinates: [
-                        [pos.sw.lon, pos.ne.lat],
-                        [pos.ne.lon, pos.ne.lat],
-                        [pos.ne.lon, pos.sw.lat],
-                        [pos.sw.lon, pos.sw.lat]
-                    ]
-                };
-                return base._d3GeoPath(route);
-            })
-            .style("fill", function (d) {
-                const retVal = context._palette(d[1], context._dataMinWeight, context._dataMaxWeight);
-                return retVal;
-            })
-            ;
-        this.geoHashPaths.exit().remove();
-    }
-
-    //  Events  ---
-    click(row, column, selected) {
-    }
-
-    dblclick(row, column, selected) {
-    }
-
-    paletteID: { (): string; (_: string): GeoHash };
-    paletteID_exists: () => boolean;
-    useClonedPalette: { (): boolean; (_: boolean): GeoHash };
-    useClonedPalette_exists: () => boolean;
-    opacity: { (): number; (_: number): GeoHash };
-    opacity_exists: () => boolean;
-    meshVisible: { (): boolean; (_: boolean): GeoHash };
-    meshVisible_exists: () => boolean;
-    meshColor: { (): string; (_: string): GeoHash };
-    meshColor_exists: () => boolean;
-    meshStrokeWidth: { (): number; (_: number): GeoHash };
-    meshStrokeWidth_exists: () => boolean;
-}
-GeoHash.prototype._class += " map_GeoHash";
-
-GeoHash.prototype._palette = Palette.rainbow("default");
-
-GeoHash.prototype.publish("paletteID", "YlOrRd", "set", "Color palette for this widget", GeoHash.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
-GeoHash.prototype.publish("useClonedPalette", false, "boolean", "Enable or disable using a cloned palette", null, { tags: ["Intermediate", "Shared"] });
-
-GeoHash.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
-
-GeoHash.prototype.publish("meshVisible", true, "boolean", "Mesh Visibility");
-GeoHash.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
-GeoHash.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");
+import { Palette, Utility as CommonUtility } from "@hpcc-js/common";
+import { select as d3Select } from "d3-selection";
+import { Layer } from "./Layer";
+import * as Utility from "./Utility";
+
+import "../src/GeoHash.css";
+
+export class GeoHash extends Layer {
+    _palette;
+    _dataMinWeight;
+    _dataMaxWeight;
+    geohash;
+    _geoHashTransform;
+    _selection;
+    geoHashPaths;
+
+    constructor() {
+        super();
+    }
+
+    data(_?) {
+        const retVal = Layer.prototype.data.apply(this, arguments);
+        if (arguments.length) {
+            this._dataMinWeight = null;
+            this._dataMaxWeight = null;
+
+            this.data().forEach(function (item) {
+                if (!this._dataMinWeight || item[1] < this._dataMinWeight) {
+                    this._dataMinWeight = item[1];
+                }
+                if (!this._dataMaxWeight || item[1] > this._dataMaxWeight) {
+                    this._dataMaxWeight = item[1];
+                }
+            }, this);
+        }
+        return retVal;
+    }
+
+    layerEnter(base, svgElement, domElement) {
+        Layer.prototype.layerEnter.apply(this, arguments);
+
+        this.geohash = new Utility.Geohash();
+        this._geoHashTransform = svgElement
+            .append("g")
+            .attr("class", "map_GeoHash")
+            ;
+        this._selection = new CommonUtility.SimpleSelection(this, this._geoHashTransform);
+        this.geoHashPaths = d3Select(null);
+    }
+
+    layerUpdate(base) {
+        Layer.prototype.layerUpdate.apply(this, arguments);
+
+        this._palette = this._palette.switch(this.paletteID());
+        if (this.useClonedPalette()) {
+            this._palette = this._palette.cloneNotExists(this.paletteID() + "_" + this.id());
+        }
+
+        this._geoHashTransform.style("opacity", this.opacity());
+
+        this.geoHashPaths = this._geoHashTransform.selectAll(".data").data(this.visible() ? this.data() : [], function (d) { return d[0]; });
+        const context = this;
+        this.geoHashPaths.enter().append("path")
+            .attr("class", "data")
+            .call(this._selection.enter.bind(this._selection))
+            .on("click", function (d) {
+                context.click(context.rowToObj(d), "weight", context._selection.selected(this));
+            })
+            .on("dblclick", function (d) {
+                context.dblclick(context.rowToObj(d), "weight", context._selection.selected(this));
+            })
+            .merge(this.geoHashPaths)
+            .attr("d", function (d) {
+                const pos = context.geohash.bounds(d[0]);
+                const route = {
+                    type: "LineString",
+                    coordinates: [
+                        [pos.sw.lon, pos.ne.lat],
+                        [pos.ne.lon, pos.ne.lat],
+                        [pos.ne.lon, pos.sw.lat],
+                        [pos.sw.lon, pos.sw.lat]
+                    ]
+                };
+                return base._d3GeoPath(route);
+            })
+            .style("fill", function (d) {
+                const retVal = context._palette(d[1], context._dataMinWeight, context._dataMaxWeight);
+                return retVal;
+            })
+            ;
+        this.geoHashPaths.exit().remove();
+    }
+
+    //  Events  ---
+    click(row, column, selected) {
+    }
+
+    dblclick(row, column, selected) {
+    }
+
+    paletteID: { (): string; (_: string): GeoHash };
+    paletteID_exists: () => boolean;
+    useClonedPalette: { (): boolean; (_: boolean): GeoHash };
+    useClonedPalette_exists: () => boolean;
+    opacity: { (): number; (_: number): GeoHash };
+    opacity_exists: () => boolean;
+    meshVisible: { (): boolean; (_: boolean): GeoHash };
+    meshVisible_exists: () => boolean;
+    meshColor: { (): string; (_: string): GeoHash };
+    meshColor_exists: () => boolean;
+    meshStrokeWidth: { (): number; (_: number): GeoHash };
+    meshStrokeWidth_exists: () => boolean;
+}
+GeoHash.prototype._class += " map_GeoHash";
+
+GeoHash.prototype._palette = Palette.rainbow("default");
+
+GeoHash.prototype.publish("paletteID", "YlOrRd", "set", "Color palette for this widget", GeoHash.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
+GeoHash.prototype.publish("useClonedPalette", false, "boolean", "Enable or disable using a cloned palette", null, { tags: ["Intermediate", "Shared"] });
+
+GeoHash.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });
+
+GeoHash.prototype.publish("meshVisible", true, "boolean", "Mesh Visibility");
+GeoHash.prototype.publish("meshColor", null, "html-color", "Stroke Color", null, { optional: true });
+GeoHash.prototype.publish("meshStrokeWidth", 0.25, "number", "Stroke Width");

package/src/Graph.css

@@ -1,10 +1,10 @@
-.map_Layered .marker {
-    fill: #656565;
-    stroke: none;
-    stroke-width: 1.0px;
-}
-
-.map_Layered .dataEdge {
-    stroke: black;
-    fill: none;
-}
+.map_Layered .marker {
+    fill: #656565;
+    stroke: none;
+    stroke-width: 1.0px;
+}
+
+.map_Layered .dataEdge {
+    stroke: black;
+    fill: none;
+}

package/src/Graph.ts

@@ -1,98 +1,98 @@
-import { Pins } from "./Pins";
-
-import "../src/Graph.css";
-
-export class Graph extends Pins {
-    dataEdges = [];
-    _edgesTransform;
-
-    constructor() {
-        super();
-    }
-
-    importJSON(_) {
-        const retVal = Pins.prototype.importJSON.apply(this, arguments);
-        if (arguments.length) {
-            this.dataEdges = [];
-            let prevPin = null;
-            _.forEach(function (row) {
-                if (prevPin) {
-                    this.dataEdges.push({
-                        type: "LineString",
-                        coordinates: [[prevPin.long, prevPin.lat], [row.long, row.lat]]
-                    });
-                }
-                if (row.eol) {
-                    prevPin = null;
-                } else {
-                    prevPin = row;
-                }
-            }, this);
-        }
-        return retVal;
-    }
-
-    data(_) {
-        const retVal = Pins.prototype.data.apply(this, arguments);
-        if (arguments.length) {
-            this.dataEdges = [];
-            let prevPin = null;
-            _.forEach(function (row) {
-                if (prevPin) {
-                    this.dataEdges.push({
-                        type: "LineString",
-                        coordinates: [[prevPin[1], prevPin[0]], [row[1], row[0]]]
-                    });
-                }
-                prevPin = row;
-            }, this);
-        }
-        return retVal;
-    }
-
-    layerEnter(base, svgElement, domElement) {
-        Pins.prototype.layerEnter.apply(this, arguments);
-
-        svgElement.append("defs").append("marker")
-            .attr("class", "marker")
-            .attr("id", this._id + "_arrowHead")
-            .attr("viewBox", "0 0 10 10")
-            .attr("refX", 10)
-            .attr("refY", 5)
-            .attr("markerWidth", 16)
-            .attr("markerHeight", 16)
-            .attr("markerUnits", "strokeWidth")
-            .attr("orient", "auto")
-            .append("polyline")
-            .attr("points", "0,0 10,5 0,10 1,5")
-            ;
-        this._edgesTransform = svgElement.append("g");
-    }
-
-    _edgesPaths;
-    layerUpdate(base) {
-        Pins.prototype.layerUpdate.apply(this, arguments);
-
-        this._edgesTransform
-            .style("opacity", this.opacity())
-            ;
-
-        const edgesPaths = this._edgesTransform.selectAll(".dataEdge").data(this.visible() ? this.dataEdges : []);
-        this._edgesPaths = edgesPaths.enter().append("path")
-            .attr("class", "dataEdge")
-            .attr("marker-end", "url(#" + this._id + "_arrowHead)")
-            .merge(edgesPaths)
-            .attr("d", base._d3GeoPath)
-            ;
-        edgesPaths.exit().remove();
-    }
-
-    layerZoomed(base) {
-        Pins.prototype.layerZoomed.apply(this, arguments);
-        this._edgesPaths
-            .attr("stroke-width", `${0.5 / base.zoomScale()}px`)
-            ;
-    }
-
-}
-Graph.prototype._class += " map_Graph";
+import { Pins } from "./Pins";
+
+import "../src/Graph.css";
+
+export class Graph extends Pins {
+    dataEdges = [];
+    _edgesTransform;
+
+    constructor() {
+        super();
+    }
+
+    importJSON(_) {
+        const retVal = Pins.prototype.importJSON.apply(this, arguments);
+        if (arguments.length) {
+            this.dataEdges = [];
+            let prevPin = null;
+            _.forEach(function (row) {
+                if (prevPin) {
+                    this.dataEdges.push({
+                        type: "LineString",
+                        coordinates: [[prevPin.long, prevPin.lat], [row.long, row.lat]]
+                    });
+                }
+                if (row.eol) {
+                    prevPin = null;
+                } else {
+                    prevPin = row;
+                }
+            }, this);
+        }
+        return retVal;
+    }
+
+    data(_) {
+        const retVal = Pins.prototype.data.apply(this, arguments);
+        if (arguments.length) {
+            this.dataEdges = [];
+            let prevPin = null;
+            _.forEach(function (row) {
+                if (prevPin) {
+                    this.dataEdges.push({
+                        type: "LineString",
+                        coordinates: [[prevPin[1], prevPin[0]], [row[1], row[0]]]
+                    });
+                }
+                prevPin = row;
+            }, this);
+        }
+        return retVal;
+    }
+
+    layerEnter(base, svgElement, domElement) {
+        Pins.prototype.layerEnter.apply(this, arguments);
+
+        svgElement.append("defs").append("marker")
+            .attr("class", "marker")
+            .attr("id", this._id + "_arrowHead")
+            .attr("viewBox", "0 0 10 10")
+            .attr("refX", 10)
+            .attr("refY", 5)
+            .attr("markerWidth", 16)
+            .attr("markerHeight", 16)
+            .attr("markerUnits", "strokeWidth")
+            .attr("orient", "auto")
+            .append("polyline")
+            .attr("points", "0,0 10,5 0,10 1,5")
+            ;
+        this._edgesTransform = svgElement.append("g");
+    }
+
+    _edgesPaths;
+    layerUpdate(base) {
+        Pins.prototype.layerUpdate.apply(this, arguments);
+
+        this._edgesTransform
+            .style("opacity", this.opacity())
+            ;
+
+        const edgesPaths = this._edgesTransform.selectAll(".dataEdge").data(this.visible() ? this.dataEdges : []);
+        this._edgesPaths = edgesPaths.enter().append("path")
+            .attr("class", "dataEdge")
+            .attr("marker-end", "url(#" + this._id + "_arrowHead)")
+            .merge(edgesPaths)
+            .attr("d", base._d3GeoPath)
+            ;
+        edgesPaths.exit().remove();
+    }
+
+    layerZoomed(base) {
+        Pins.prototype.layerZoomed.apply(this, arguments);
+        this._edgesPaths
+            .attr("stroke-width", `${0.5 / base.zoomScale()}px`)
+            ;
+    }
+
+}
+Graph.prototype._class += " map_Graph";

package/src/Graticule.css

@@ -1,13 +1,13 @@
-.map_Layered .graticule {
-  fill: none;
-  stroke: darkgray;
-  stroke-linejoin: round;
-  stroke-width: 0.25px;
-}
-
-.map_Layered .graticuleOutline {
-  fill: none;
-  stroke: black;
-  stroke-linejoin: round;
-  stroke-width: 0.25px;
-}
+.map_Layered .graticule {
+  fill: none;
+  stroke: darkgray;
+  stroke-linejoin: round;
+  stroke-width: 0.25px;
+}
+
+.map_Layered .graticuleOutline {
+  fill: none;
+  stroke: black;
+  stroke-linejoin: round;
+  stroke-width: 0.25px;
+}