@hpcc-js/map 2.79.0 → 3.1.0

package/src/Layer.ts

@@ -1,5 +1,5 @@
 import { ITooltip } from "@hpcc-js/api";
-import { Layered } from "./Layered";
+import { Layered } from "./Layered.ts";
 
 export class Layer extends Layered {
     _svgElement;
@@ -65,26 +65,35 @@ export class Layer extends Layered {
 
     layerZoomed(base) {
     }
+}
+Layer.prototype._class += " map_Layer";
+Layer.prototype.implements(ITooltip.prototype);
 
+export interface Layer {
     //  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;
+    tooltipHTML(_: any): any;
+    tooltipFormat(opts: any): string;
+    tooltipStyle(): string;
+    tooltipStyle(_: string): Layer;
+    tooltipStyle_exists(): boolean;
+    tooltipValueFormat(): string;
+    tooltipValueFormat(_: string): Layer;
+    tooltipValueFormat_exists(): boolean;
+    tooltipSeriesColor(): string;
+    tooltipSeriesColor(_: string): Layer;
+    tooltipSeriesColor_exists(): boolean;
+    tooltipLabelColor(): string;
+    tooltipLabelColor(_: string): Layer;
+    tooltipLabelColor_exists(): boolean;
+    tooltipValueColor(): string;
+    tooltipValueColor(_: string): Layer;
+    tooltipValueColor_exists(): boolean;
+    tooltipTick(): boolean;
+    tooltipTick(_: boolean): Layer;
+    tooltipTick_exists(): boolean;
+    tooltipOffset(): number;
+    tooltipOffset(_: number): Layer;
+    tooltipOffset_exists(): boolean;
 }
-Layer.prototype._class += " map_Layer";
-Layer.prototype.implements(ITooltip.prototype);

package/src/Layered.ts

@@ -1,7 +1,7 @@
 import { SVGZoomWidget } from "@hpcc-js/common";
 import { geoPath as d3GeoPath } from "d3-geo";
 import { select as d3Select } from "d3-selection";
-import { resolve, types as projectionTypes } from "./Projection";
+import { resolve, types as projectionTypes } from "./Projection.ts";
 import "./Utility"; // For albersUsaPr
 
 import "../src/Layered.css";

package/src/Lines.ts

@@ -1,4 +1,4 @@
-import { Layer } from "./Layer";
+import { Layer } from "./Layer.ts";
 
 import "../src/Lines.css";
 
@@ -67,9 +67,12 @@ export class Lines extends Layer {
             .attr("stroke-width", `${0.5 / base.zoomScale()}px`)
             ;
     }
-
-    opacity: { (): number; (_: number): Lines };
 }
 Lines.prototype._class += " map_Lines";
 
+export interface Lines {
+    opacity(): number;
+    opacity(_: number): this;
+}
+
 Lines.prototype.publish("opacity", 1.0, "number", "Opacity", null, { tags: ["Advanced"] });

package/src/OpenStreet.ts

@@ -1,6 +1,6 @@
 import { select as d3Select } from "d3-selection";
 import { tile as d3Tile } from "d3-tile";
-import { Layer } from "./Layer";
+import { Layer } from "./Layer.ts";
 
 // import * as Utility from "./Utility";
 
@@ -109,12 +109,15 @@ export class OpenStreet extends Layer {
             .style("opacity", 1)
             ;
     }
-
-    tileProvider: { (): string; (_: string): OpenStreet };
-    tileProvider_exists: () => boolean;
 }
 OpenStreet.prototype._class += " map_OpenStreet";
 
+export interface OpenStreet {
+    tileProvider(): string;
+    tileProvider(_: string): this;
+    tileProvider_exists(): boolean;
+}
+
 OpenStreet.prototype.publish("tileProvider", "OpenStreetMap", "set", "Tile Provider", ["OpenStreetMap", "OpenStreetMap Hot", "MapQuest", "MapQuest Sat", "Stamen Watercolor", "OpenCycleMap"], { tags: ["Basic", "Shared"] });
 
 function stringify(scale, translate) {

package/src/Pins.ts

@@ -1,14 +1,13 @@
 import { Platform, Utility } from "@hpcc-js/common";
 import { select as d3Select } from "d3-selection";
-import { Layer } from "./Layer";
-import * as MapUtility from "./Utility";
+import { Layer } from "./Layer.ts";
+import * as MapUtility from "./Utility.ts";
 
 import "../src/Pins.css";
 
 export class Pins extends Layer {
     _geohash;
     _pinsTransform;
-    _selection;
     pinsPaths;
 
     constructor() {
@@ -246,51 +245,83 @@ export class Pins extends Layer {
 
     dblclick(row, column, selected) {
     }
-
-    latColumn: { (): string; (_: string): Pins };
-    latColumn_exists: () => boolean;
-    longColumn: { (): string; (_: string): Pins };
-    longColumn_exists: () => boolean;
-    geohashColumn: { (): string; (_: string): Pins };
-    geohashColumn_exists: () => boolean;
-    tooltipColumn: { (): string; (_: string): Pins };
-    tooltipColumn_exists: () => boolean;
-    opacity: { (): number; (_: number): Pins };
-    opacity_exists: () => boolean;
-    fillColor: { (): string; (_: string): Pins };
-    fillColor_exists: () => boolean;
-    omitNullLatLong: { (): boolean; (_: boolean): Pins };
-    omitNullLatLong_exists: () => boolean;
-    strokeWidth: { (): number; (_: number): Pins };
-    strokeWidth_exists: () => boolean;
-    strokeColor: { (): string; (_: string): Pins };
-    strokeColor_exists: () => boolean;
-    fontSize: { (): number; (_: number): Pins };
-    fontSize_exists: () => boolean;
-    fontFamily: { (): string; (_: string): Pins };
-    fontFamily_exists: () => boolean;
-    fontColor: { (): string; (_: string): Pins };
-    fontColor_exists: () => boolean;
-    pinType: { (): string; (_: string): Pins };
-    pinType_exists: () => boolean;
-    arrowWidth: { (): number; (_: number): Pins };
-    arrowWidth_exists: () => boolean;
-    arrowHeight: { (): number; (_: number): Pins };
-    arrowHeight_exists: () => boolean;
-    pinWidth: { (): number; (_: number): Pins };
-    pinWidth_exists: () => boolean;
-    pinHeight: { (): number; (_: number): Pins };
-    pinHeight_exists: () => boolean;
-    cornerRadius: { (): number; (_: number): Pins };
-    cornerRadius_exists: () => boolean;
-    pinRadius: { (): number; (_: number): Pins };
-    pinRadius_exists: () => boolean;
-    textBaseline: { (): string; (_: string): Pins };
-    textBaseline_exists: () => boolean;
 }
 Pins.prototype._class += " map_Pins";
 Pins.prototype.mixin(Utility.SimpleSelectionMixin);
 
+export interface Pins {
+    // Simple Selection  ---
+    _selection;
+
+    //  Properties  ---
+    latColumn(): string;
+    latColumn(_: string): this;
+    latColumn_exists(): boolean;
+    longColumn(): string;
+    longColumn(_: string): this;
+    longColumn_exists(): boolean;
+    geohashColumn(): string;
+    geohashColumn(_: string): this;
+    geohashColumn_exists(): boolean;
+    tooltipColumn(): string;
+    tooltipColumn(_: string): this;
+    tooltipColumn_exists(): boolean;
+    opacity(): number;
+    opacity(_: number): this;
+    opacity_exists(): boolean;
+    fillColor(): string;
+    fillColor(_: string): this;
+    fillColor_exists(): boolean;
+    omitNullLatLong(): boolean;
+    omitNullLatLong(_: boolean): this;
+    omitNullLatLong_exists(): boolean;
+
+    strokeWidth(): number;
+    strokeWidth(_: number): this;
+    strokeWidth_exists(): boolean;
+    strokeColor(): string;
+    strokeColor(_: string): this;
+    strokeColor_exists(): boolean;
+
+    fontSize(): number;
+    fontSize(_: number): this;
+    fontSize_exists(): boolean;
+    fontFamily(): string;
+    fontFamily(_: string): this;
+    fontFamily_exists(): boolean;
+    fontColor(): string;
+    fontColor(_: string): this;
+    fontColor_exists(): boolean;
+
+    pinType(): string;
+    pinType(_: string): this;
+    pinType_exists(): boolean;
+    arrowWidth(): number;
+    arrowWidth(_: number): this;
+    arrowWidth_exists(): boolean;
+    arrowHeight(): number;
+    arrowHeight(_: number): this;
+    arrowHeight_exists(): boolean;
+
+    pinWidth(): number;
+    pinWidth(_: number): this;
+    pinWidth_exists(): boolean;
+    pinHeight(): number;
+    pinHeight(_: number): this;
+    pinHeight_exists(): boolean;
+    cornerRadius(): number;
+    cornerRadius(_: number): this;
+    cornerRadius_exists(): boolean;
+
+    pinRadius(): number;
+    pinRadius(_: number): this;
+    pinRadius_exists(): boolean;
+
+    textBaseline(): string;
+    textBaseline(_: string): this;
+    textBaseline_exists(): boolean;
+}
+
 Pins.prototype.publish("geohashColumn", null, "set", "Geohash column", function () { return this.columns(); }, { optional: true });
 Pins.prototype.publish("tooltipColumn", null, "set", "Tooltip column", function () { return this.columns(); }, { optional: true });
 Pins.prototype.publish("latColumn", null, "set", "Latitude column", function () { return this.columns(); }, { optional: true });

package/src/Projection.ts

@@ -1,5 +1,5 @@
 import * as d3Geo from "d3-geo";
-import { albersUsaPr } from "./Utility";
+import { albersUsaPr } from "./Utility.ts";
 
 // const d3Geo = _d3Geo.geo || _d3Geo.default || _d3Geo;
 

package/src/TestHeatMap.ts

@@ -1,4 +1,4 @@
-import { Layered } from "./Layered";
+import { Layered } from "./Layered.ts";
 
 export class TestHeatMap extends Layered {
     constructor() {

package/src/TopoJSONChoropleth.ts

@@ -1,114 +1,125 @@
 import { json as d3Json } from "d3-request";
 import { select as d3Select } from "d3-selection";
 import * as topojson from "topojson-client";
-import { Choropleth, topoJsonFolder } from "./Choropleth";
+import { Choropleth, topoJsonFolder } from "./Choropleth.ts";
 
-export function TopoJSONChoropleth() {
-    Choropleth.call(this);
+export class TopoJSONChoropleth extends Choropleth {
+    protected _prevRegion: string;
+    protected choroPaths: any;
+    protected _choroTopologyIndex: any;
+    protected _choroTopologyFeatures: any;
 
-    this.projection("Mercator");
-}
-TopoJSONChoropleth.prototype = Object.create(Choropleth.prototype);
-TopoJSONChoropleth.prototype.constructor = TopoJSONChoropleth;
-TopoJSONChoropleth.prototype._class += " map_TopoJSONChoropleth";
+    constructor() {
+        super();
 
-TopoJSONChoropleth.prototype.publish("region", "GB", "set", "Region Data", ["AT", "BE", "BG", "BR", "CHLI", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GB", "GE", "GR", "HR", "HU", "IE", "IS", "IT", "KS", "LT", "LU", "LV", "MD", "MK", "MT", "ND", "NL", "NO", "PL", "PT", "RO", "RS", "SE", "SI", "SK", "UA"]);
+        this.projection("Mercator");
+    }
 
-TopoJSONChoropleth.prototype.layerEnter = function (base, svgElement, domElement) {
-    Choropleth.prototype.layerEnter.apply(this, arguments);
+    layerEnter(base, svgElement, domElement) {
+        Choropleth.prototype.layerEnter.apply(this, arguments);
 
-    this._selection.widgetElement(this._choroplethData);
-    this.choroPaths = d3Select(null);
+        this._selection.widgetElement(this._choroplethData);
+        this.choroPaths = d3Select(null);
 
-    const context = this;
-    this
-        .tooltipHTML(function (d) {
-            const columns = context.columns();
-            const series = columns && columns.length ? columns[0] : "Location";
-            const origData = d && d.length ? d[d.length - 1] : [""];
-            return context.tooltipFormat({ label: origData[0], series, value: d[1] });
-        })
-        ;
-};
+        const context = this;
+        this
+            .tooltipHTML(function (d) {
+                const columns = context.columns();
+                const series = columns && columns.length ? columns[0] : "Location";
+                const origData = d && d.length ? d[d.length - 1] : [""];
+                return context.tooltipFormat({ label: origData[0], series, value: d[1] });
+            })
+            ;
+    }
 
-TopoJSONChoropleth.prototype.layerUpdate = function (base) {
-    Choropleth.prototype.layerUpdate.apply(this, arguments);
-    const data = [];
-    const context = this;
-    this.data().forEach(function (row) {
-        if (isNaN(row[0])) {
-            for (const key in context._choroTopologyIndex) {
-                for (const key2 in context._choroTopologyIndex[key]) {
-                    if (key2 === row[0]) {
-                        context._choroTopologyIndex[key][key2].forEach(function (idx) {
-                            data.push([idx].concat(row.filter(function (d, i) { return i > 0; })).concat([row]));
-                        });
+    layerUpdate(base) {
+        Choropleth.prototype.layerUpdate.apply(this, arguments);
+        const data = [];
+        const context = this;
+        this.data().forEach(function (row) {
+            if (isNaN(row[0])) {
+                for (const key in context._choroTopologyIndex) {
+                    for (const key2 in context._choroTopologyIndex[key]) {
+                        if (key2 === row[0]) {
+                            context._choroTopologyIndex[key][key2].forEach(function (idx) {
+                                data.push([idx].concat(row.filter(function (d, i) { return i > 0; })).concat([row]));
+                            });
+                        }
                     }
                 }
+            } else {
+                data.push(row.concat([row]));
             }
-        } else {
-            data.push(row.concat([row]));
-        }
-    });
-    this.choroPaths = this._choroplethData.selectAll(".data").data(this.visible() ? data : [], function (d) { return d[0]; });
-    this.choroPaths.enter().append("path")
-        .attr("class", "data")
-        .call(this._selection.enter.bind(this._selection))
-        .on("click", function (d) {
-            if (context._dataMap[d[0]]) {
-                context.click(context.rowToObj(context._dataMap[d[0]]), "weight", context._selection.selected(context));
-            }
-        })
-        .on("dblclick", function (d) {
-            if (context._dataMap[d[0]]) {
-                context.dblclick(context.rowToObj(context._dataMap[d[0]]), "weight", context._selection.selected(context));
-            }
-        })
-        .on("mouseout.tooltip", this.tooltip.hide)
-        .on("mousemove.tooltip", this.tooltip.show)
-        ;
-    this.choroPaths
-        .attr("d", function (d) {
-            const retVal = base._d3GeoPath(context._choroTopologyFeatures[d[0]]);
-            if (!retVal) {
-                console.warn("Unknown Country:  " + d);
-            }
-            return retVal;
-        })
-        .style("fill", function (d) {
-            const retVal = context._palette(d[1], context._dataMinWeight, context._dataMaxWeight);
-            return retVal;
-        })
-        ;
-    this.choroPaths.exit().remove();
-};
-
-TopoJSONChoropleth.prototype.layerPreRender = function () {
-    if (this._prevRegion !== this.region()) {
-        this._prevRegion = this.region();
-        delete this._topoJsonPromise;
+        });
+        this.choroPaths = this._choroplethData.selectAll(".data").data(this.visible() ? data : [], function (d) { return d[0]; });
+        this.choroPaths.enter().append("path")
+            .attr("class", "data")
+            .call(this._selection.enter.bind(this._selection))
+            .on("click", function (d) {
+                if (context._dataMap[d[0]]) {
+                    context.click(context.rowToObj(context._dataMap[d[0]]), "weight", context._selection.selected(context));
+                }
+            })
+            .on("dblclick", function (d) {
+                if (context._dataMap[d[0]]) {
+                    context.dblclick(context.rowToObj(context._dataMap[d[0]]), "weight", context._selection.selected(context));
+                }
+            })
+            .on("mouseout.tooltip", this.tooltip.hide)
+            .on("mousemove.tooltip", this.tooltip.show)
+            ;
+        this.choroPaths
+            .attr("d", function (d) {
+                const retVal = base._d3GeoPath(context._choroTopologyFeatures[d[0]]);
+                if (!retVal) {
+                    console.warn("Unknown Country:  " + d);
+                }
+                return retVal;
+            })
+            .style("fill", function (d) {
+                const retVal = context._palette(d[1], context._dataMinWeight, context._dataMaxWeight);
+                return retVal;
+            })
+            ;
+        this.choroPaths.exit().remove();
     }
 
-    if (!this._topoJsonPromise) {
-        const context = this;
-        this._topoJsonPromise = new Promise<void>(function (resolve, reject) {
-            d3Json(`${topoJsonFolder()}/${context.region()}.json`, function (region) {
-                context._choroTopology = region;
-                context._choroTopologyObjects = region.objects.PolbndA;
-                context._choroTopologyFeatures = topojson.feature(context._choroTopology, context._choroTopologyObjects).features;
+    layerPreRender() {
+        if (this._prevRegion !== this.region()) {
+            this._prevRegion = this.region();
+            delete this._topoJsonPromise;
+        }
 
-                d3Json(`${topoJsonFolder()}/${context.region()}_idx.json`, indexLoad)
-                    .on("error", function (err) {
-                        indexLoad({});
-                    })
-                    ;
+        if (!this._topoJsonPromise) {
+            const context = this;
+            this._topoJsonPromise = new Promise<void>(function (resolve, reject) {
+                d3Json(`${topoJsonFolder()}/${context.region()}.json`, function (region) {
+                    context._choroTopology = region;
+                    context._choroTopologyObjects = region.objects.PolbndA;
+                    context._choroTopologyFeatures = topojson.feature(context._choroTopology, context._choroTopologyObjects).features;
 
-                function indexLoad(index) {
-                    context._choroTopologyIndex = index;
-                    resolve();
-                }
+                    d3Json(`${topoJsonFolder()}/${context.region()}_idx.json`, indexLoad)
+                        .on("error", function (err) {
+                            indexLoad({});
+                        })
+                        ;
+
+                    function indexLoad(index) {
+                        context._choroTopologyIndex = index;
+                        resolve();
+                    }
+                });
             });
-        });
+        }
+        return this._topoJsonPromise;
     }
-    return this._topoJsonPromise;
-};
+}
+TopoJSONChoropleth.prototype._class += " map_TopoJSONChoropleth";
+
+export interface TopoJSONChoropleth {
+    region(): string;
+    region(_: string): this;
+    region_exists(): boolean;
+}
+
+TopoJSONChoropleth.prototype.publish("region", "GB", "set", "Region Data", ["AT", "BE", "BG", "BR", "CHLI", "CY", "CZ", "DE", "DK", "EE", "ES", "FI", "FR", "GB", "GE", "GR", "HR", "HU", "IE", "IS", "IT", "KS", "LT", "LU", "LV", "MD", "MK", "MT", "ND", "NL", "NO", "PL", "PT", "RO", "RS", "SE", "SI", "SK", "UA"]);

package/src/__package__.ts

@@ -1,3 +1,3 @@
 export const PKG_NAME = "@hpcc-js/map";
-export const PKG_VERSION = "2.79.0";
-export const BUILD_VERSION = "2.107.0";
+export const PKG_VERSION = "3.1.0";
+export const BUILD_VERSION = "3.2.0";

package/src/index.ts

@@ -1,34 +1,33 @@
-export * from "./__package__";
-export * from "./CanvasPinLayer";
-export * from "./CanvasPins";
-export * from "./Choropleth";
-export * from "./ChoroplethContinents";
-export * from "./ChoroplethCounties";
-export * from "./ChoroplethCountries";
-export * from "./ChoroplethStates";
-export * from "./ChoroplethStatesHeat";
-export * from "./GeoHash";
-export * from "./GMap";
-export * from "./GMapCounties";
-export * from "./GMapGraph";
-export * from "./GMapHeat";
-export * from "./GMapLayered";
-export * from "./GMapPin";
-export * from "./GMapPinLine";
-export * from "./Graph";
-export * from "./Graticule";
-export * from "./Heat";
-export * from "./IChoropleth";
-export * from "./Layer";
-export * from "./Layered";
-export * from "./Lines";
-export * from "./OpenStreet";
-export * from "./Pins";
-export * from "./Projection";
-export * from "./TestHeatMap";
-export * from "./TopoJSONChoropleth";
+export * from "./__package__.ts";
+export * from "./CanvasPinLayer.ts";
+export * from "./CanvasPins.ts";
+export * from "./Choropleth.ts";
+export * from "./ChoroplethContinents.ts";
+export * from "./ChoroplethCounties.ts";
+export * from "./ChoroplethCountries.ts";
+export * from "./ChoroplethStates.ts";
+export * from "./ChoroplethStatesHeat.ts";
+export * from "./GeoHash.ts";
+export * from "./GMap.ts";
+export * from "./GMapCounties.ts";
+export * from "./GMapGraph.ts";
+export * from "./GMapHeat.ts";
+export * from "./GMapLayered.ts";
+export * from "./GMapPin.ts";
+export * from "./GMapPinLine.ts";
+export * from "./Graph.ts";
+export * from "./Graticule.ts";
+export * from "./Heat.ts";
+export * from "./IChoropleth.ts";
+export * from "./Layer.ts";
+export * from "./Layered.ts";
+export * from "./Lines.ts";
+export * from "./OpenStreet.ts";
+export * from "./Pins.ts";
+export * from "./Projection.ts";
+export * from "./TopoJSONChoropleth.ts";
 
-import * as Leaflet from "./leaflet/index";
+import * as Leaflet from "./leaflet/index.ts";
 export {
     Leaflet
 };

package/src/leaflet/AlbersPR.ts

@@ -1,6 +1,6 @@
-import { CRS, LatLng, LatLngBounds, Point, Transformation, Util } from "@hpcc-js/leaflet-shim";
-import { resolve } from "../Projection";
-import { TileLayer } from "./TileLayer";
+import { CRS, LatLng, LatLngBounds, Point, Transformation, Util } from "./leaflet-shim.ts";
+import { resolve } from "../Projection.ts";
+import { TileLayer } from "./TileLayer.ts";
 
 const projAlbers = resolve("Albers").scale(.5);
 const projAlbersUsaPr = resolve("AlbersUsaPr").scale(.5);

package/src/leaflet/Blank.ts

@@ -1,4 +1,4 @@
-import { TileLayer } from "./TileLayer";
+import { TileLayer } from "./TileLayer.ts";
 
 export class BlankLayer extends TileLayer {
 

package/src/leaflet/Circles.ts

@@ -1,5 +1,5 @@
-import { Circle, Map } from "@hpcc-js/leaflet-shim";
-import { ClusterLayer, D3SurfaceLayer } from "./FeatureLayer";
+import { Circle, Map } from "./leaflet-shim.ts";
+import { ClusterLayer, D3SurfaceLayer } from "./FeatureLayer.ts";
 
 export class Circles extends ClusterLayer {
 

package/src/leaflet/ClusterCircles.ts

@@ -1,8 +1,8 @@
 import { extent as d3Extent, Palette } from "@hpcc-js/common";
-import { DivIcon, Map, Marker, Point } from "@hpcc-js/leaflet-shim";
+import { DivIcon, Map, Marker, Point } from "./leaflet-shim.ts";
 import { hsl as d3Hsl } from "d3-color";
 import { format as d3Format } from "d3-format";
-import { FeatureLayer } from "./FeatureLayer";
+import { FeatureLayer } from "./FeatureLayer.ts";
 
 import "../../src/leaflet/ClusterCircles.css";
 

package/src/leaflet/Countries.ts

@@ -1,7 +1,7 @@
 import { json as d3Json } from "d3-request";
 import * as topojson from "topojson-client";
-import { topoJsonFolder } from "../Choropleth";
-import { World } from "./World";
+import { topoJsonFolder } from "../Choropleth.ts";
+import { World } from "./World.ts";
 
 let countries = null;
 

package/src/leaflet/DrawLayer.ts

@@ -1,6 +1,6 @@
-import { Circle, Control, Draw, LatLng, LatLngBounds, LatLngExpression, Map, Polygon, Polyline, Rectangle } from "@hpcc-js/leaflet-shim";
+import { Circle, Control, Draw, LatLng, LatLngBounds, LatLngExpression, Map, Polygon, Polyline, Rectangle } from "./leaflet-shim.ts";
 import { hashSum } from "@hpcc-js/util";
-import { FeatureLayer } from "./FeatureLayer";
+import { FeatureLayer } from "./FeatureLayer.ts";
 
 function del(arr: any[], item: object) {
     const idx = arr.indexOf(item);

package/src/leaflet/FeatureLayer.ts

@@ -1,7 +1,7 @@
 import { HTMLWidget, select as d3Select, Utility } from "@hpcc-js/common";
-import { D3SvgOverlay, FeatureGroup, LatLngBounds, LeafletEvent, Map, MarkerClusterGroup } from "@hpcc-js/leaflet-shim";
-import { Leaflet } from "./Leaflet";
-import { ILayer } from "./TileLayer";
+import { D3SvgOverlay, FeatureGroup, LatLngBounds, LeafletEvent, Map, MarkerClusterGroup } from "./leaflet-shim.ts";
+import { Leaflet } from "./Leaflet.ts";
+import { ILayer } from "./TileLayer.ts";
 
 export class FeatureLayer extends Leaflet implements ILayer {
     protected _layer: FeatureGroup | MarkerClusterGroup;