@progress/kendo-react-map 5.3.0-dev.202205051853

package/dist/es/events/preventable-event.js

@@ -0,0 +1,44 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * @hidden
+ */
+var PreventableEvent = /** @class */ (function (_super) {
+    __extends(PreventableEvent, _super);
+    function PreventableEvent() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.prevented = false;
+        return _this;
+    }
+    /* eslint-disable max-len */
+    /**
+     * Prevents the default action for a specified event. In this way, the source component suppresses the built-in behavior that follows the event.
+     */
+    PreventableEvent.prototype.preventDefault = function () {
+        this.prevented = true;
+    };
+    /**
+     * Returns `true` if the event was prevented by any of its subscribers.
+     *
+     * @returns `true` if the default action was prevented.
+     * Otherwise, returns `false`.
+     */
+    PreventableEvent.prototype.isDefaultPrevented = function () {
+        return this.prevented;
+    };
+    return PreventableEvent;
+}(BaseEvent));
+export { PreventableEvent };
+// tslint:enable:max-line-length

package/dist/es/events/reset-event.d.ts

@@ -0,0 +1,14 @@
+import { MapResetEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the map is reset.
+ *
+ * This typically occurs on initial load and after a zoom/center change.
+ */
+export declare class ResetEvent extends BaseEvent implements MapResetEvent {
+    /**
+     * @hidden
+     */
+    constructor(_: any, target: Map);
+}

package/dist/es/events/reset-event.js

@@ -0,0 +1,30 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the map is reset.
+ *
+ * This typically occurs on initial load and after a zoom/center change.
+ */
+var ResetEvent = /** @class */ (function (_super) {
+    __extends(ResetEvent, _super);
+    /**
+     * @hidden
+     */
+    function ResetEvent(_, target) {
+        return _super.call(this, target) || this;
+    }
+    return ResetEvent;
+}(BaseEvent));
+export { ResetEvent };

package/dist/es/events/shape-click-event.d.ts

@@ -0,0 +1,25 @@
+import { MapLayer, MapShapeClickEvent } from '@progress/kendo-charts';
+import { Element } from '@progress/kendo-drawing';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a shape is clicked or tapped.
+ */
+export declare class ShapeClickEvent extends BaseEvent implements MapShapeClickEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeClickEvent, target: Map);
+}

package/dist/es/events/shape-click-event.js

@@ -0,0 +1,32 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a shape is clicked or tapped.
+ */
+var ShapeClickEvent = /** @class */ (function (_super) {
+    __extends(ShapeClickEvent, _super);
+    /**
+     * @hidden
+     */
+    function ShapeClickEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.layer = e.layer;
+        _this.shape = e.shape;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return ShapeClickEvent;
+}(BaseEvent));
+export { ShapeClickEvent };

package/dist/es/events/shape-created-event.d.ts

@@ -0,0 +1,29 @@
+import { MapLayer, MapShapeCreatedEvent, Location } from '@progress/kendo-charts';
+import { Element } from '@progress/kendo-drawing';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a shape is created, but is not rendered yet.
+ */
+export declare class ShapeCreatedEvent extends BaseEvent implements MapShapeCreatedEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The original data item for this Shape.
+     */
+    dataItem: any;
+    /**
+     * The shape location
+     */
+    location: Location;
+    /**
+     * @hidden
+     */
+    constructor(e: any, target: Map);
+}

package/dist/es/events/shape-created-event.js

@@ -0,0 +1,35 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a shape is created, but is not rendered yet.
+ */
+var ShapeCreatedEvent = /** @class */ (function (_super) {
+    __extends(ShapeCreatedEvent, _super);
+    /**
+     * @hidden
+     */
+    function ShapeCreatedEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.layer = e.layer;
+        _this.shape = e.shape;
+        if (e.shape) {
+            _this.dataItem = e.shape.dataItem;
+            _this.location = e.shape.location;
+        }
+        return _this;
+    }
+    return ShapeCreatedEvent;
+}(BaseEvent));
+export { ShapeCreatedEvent };

package/dist/es/events/shape-feature-created-event.d.ts

@@ -0,0 +1,29 @@
+import { MapLayer, MapShapeFeatureCreatedEvent } from '@progress/kendo-charts';
+import { Group } from '@progress/kendo-drawing';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+ */
+export declare class ShapeFeatureCreatedEvent extends BaseEvent implements MapShapeFeatureCreatedEvent {
+    /**
+     * The original data item for this Feature. Members include `geometries` and `properties`.
+     */
+    dataItem: any;
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The group containing feature shape instances.
+     */
+    group: Group;
+    /**
+     * A reference to the `dataItem.properties` object.
+     */
+    properties: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeFeatureCreatedEvent, target: Map);
+}

package/dist/es/events/shape-feature-created-event.js

@@ -0,0 +1,33 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a [GeoJSON Feature](https://geojson.org/geojson-spec.html#feature-objects) is created on a shape layer.
+ */
+var ShapeFeatureCreatedEvent = /** @class */ (function (_super) {
+    __extends(ShapeFeatureCreatedEvent, _super);
+    /**
+     * @hidden
+     */
+    function ShapeFeatureCreatedEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.dataItem = e.dataItem;
+        _this.layer = e.layer;
+        _this.group = e.group;
+        _this.properties = e.properties;
+        return _this;
+    }
+    return ShapeFeatureCreatedEvent;
+}(BaseEvent));
+export { ShapeFeatureCreatedEvent };

package/dist/es/events/shape-mouse-enter-event.d.ts

@@ -0,0 +1,28 @@
+import { MapLayer, MapShapeMouseEnterEvent } from '@progress/kendo-charts';
+import { Element } from '@progress/kendo-drawing';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the mouse enters a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+export declare class ShapeMouseEnterEvent extends BaseEvent implements MapShapeMouseEnterEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeMouseEnterEvent, target: Map);
+}

package/dist/es/events/shape-mouse-enter-event.js

@@ -0,0 +1,35 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the mouse enters a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+var ShapeMouseEnterEvent = /** @class */ (function (_super) {
+    __extends(ShapeMouseEnterEvent, _super);
+    /**
+     * @hidden
+     */
+    function ShapeMouseEnterEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.layer = e.layer;
+        _this.shape = e.shape;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return ShapeMouseEnterEvent;
+}(BaseEvent));
+export { ShapeMouseEnterEvent };

package/dist/es/events/shape-mouse-leave-event.d.ts

@@ -0,0 +1,28 @@
+import { MapLayer, MapShapeMouseLeaveEvent } from '@progress/kendo-charts';
+import { Element } from '@progress/kendo-drawing';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the mouse leaves a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+export declare class ShapeMouseLeaveEvent extends BaseEvent implements MapShapeMouseLeaveEvent {
+    /**
+     * The shape layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * The shape instance.
+     */
+    shape: Element;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapShapeMouseLeaveEvent, target: Map);
+}

package/dist/es/events/shape-mouse-leave-event.js

@@ -0,0 +1,35 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the mouse leaves a shape.
+ *
+ * > This event will fire reliably only for shapes that have set fill color.
+ * > The opacity can still be set to 0 so the shapes appear to have no fill.
+ */
+var ShapeMouseLeaveEvent = /** @class */ (function (_super) {
+    __extends(ShapeMouseLeaveEvent, _super);
+    /**
+     * @hidden
+     */
+    function ShapeMouseLeaveEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.layer = e.layer;
+        _this.shape = e.shape;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return ShapeMouseLeaveEvent;
+}(BaseEvent));
+export { ShapeMouseLeaveEvent };

package/dist/es/events/zoom-end-event.d.ts

@@ -0,0 +1,16 @@
+import { MapZoomEndEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the map zoom level has changed.
+ */
+export declare class ZoomEndEvent extends BaseEvent implements MapZoomEndEvent {
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapZoomEndEvent, target: Map);
+}

package/dist/es/events/zoom-end-event.js

@@ -0,0 +1,30 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the map zoom level has changed.
+ */
+var ZoomEndEvent = /** @class */ (function (_super) {
+    __extends(ZoomEndEvent, _super);
+    /**
+     * @hidden
+     */
+    function ZoomEndEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return ZoomEndEvent;
+}(BaseEvent));
+export { ZoomEndEvent };

package/dist/es/events/zoom-start-event.d.ts

@@ -0,0 +1,18 @@
+import { MapZoomStartEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { PreventableEvent } from './preventable-event';
+/**
+ * Fired when the map zoom level is about to change.
+ *
+ * Cancelling the event will prevent the user action.
+ */
+export declare class ZoomStartEvent extends PreventableEvent implements MapZoomStartEvent {
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapZoomStartEvent, target: Map);
+}

package/dist/es/events/zoom-start-event.js

@@ -0,0 +1,32 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { PreventableEvent } from './preventable-event';
+/**
+ * Fired when the map zoom level is about to change.
+ *
+ * Cancelling the event will prevent the user action.
+ */
+var ZoomStartEvent = /** @class */ (function (_super) {
+    __extends(ZoomStartEvent, _super);
+    /**
+     * @hidden
+     */
+    function ZoomStartEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return ZoomStartEvent;
+}(PreventableEvent));
+export { ZoomStartEvent };

package/dist/es/main.d.ts

@@ -0,0 +1,6 @@
+import { Map } from './Map';
+import { MapProps } from './MapProps';
+export * from './components/main';
+export * from './common/map-types';
+export * from './common/events';
+export { Map, MapProps };

package/dist/es/main.js

@@ -0,0 +1,5 @@
+import { Map } from './Map';
+export * from './components/main';
+export * from './common/map-types';
+export * from './common/events';
+export { Map };

package/dist/es/package-metadata.d.ts

@@ -0,0 +1,5 @@
+import { PackageMetadata } from '@progress/kendo-licensing';
+/**
+ * @hidden
+ */
+export declare const packageMetadata: PackageMetadata;

package/dist/es/package-metadata.js

@@ -0,0 +1,11 @@
+/**
+ * @hidden
+ */
+export var packageMetadata = {
+    name: '@progress/kendo-react-map',
+    productName: 'KendoReact',
+    productCodes: ['KENDOUIREACT', 'KENDOUICOMPLETE'],
+    publishDate: 1651776660,
+    version: '',
+    licensingDocsUrl: 'https://www.telerik.com/kendo-react-ui/my-license/?utm_medium=product&utm_source=kendoreact&utm_campaign=kendo-ui-react-purchase-license-keys-warning'
+};

package/dist/es/store/reducer.d.ts

@@ -0,0 +1,10 @@
+import { StoreAction } from './store';
+/**
+ * @hidden
+ */
+declare const optionsReducer: (currentState: any, action: StoreAction) => object;
+/**
+ * @hidden
+ */
+declare const observersReducer: (currentState: any, action: StoreAction) => any;
+export { optionsReducer, observersReducer };

package/dist/es/store/reducer.js

@@ -0,0 +1,75 @@
+/**
+ * @hidden
+ */
+var optionsReducer = function (currentState, action) {
+    if (action.mapCollectionIdxKey) {
+        return reducers.collectionConfigurationItem(currentState, action);
+    }
+    else if (action.mapKey) {
+        return reducers.configurationItem(currentState, action);
+    }
+    else {
+        return {};
+    }
+};
+/**
+ * @hidden
+ */
+var observersReducer = function (currentState, action) {
+    if (action.type) {
+        switch (action.type) {
+            case 'add':
+                return currentState.concat([action.payload]);
+            case 'remove':
+                return currentState.filter(function (element) { return element !== action.payload; });
+            default:
+                return currentState;
+        }
+    }
+    else {
+        return [];
+    }
+};
+/**
+ * @hidden
+ */
+var reducers = {
+    configurationItem: function (currentState, action) {
+        var _a;
+        return Object.assign(currentState, (_a = {},
+            _a[action.mapKey] = action.payload,
+            _a));
+    },
+    collectionConfigurationItem: function (currentState, action) {
+        var _a;
+        var inCollection = false;
+        var _b = action.mapCollectionIdxKey.split('_'), collectionName = _b[0], collectionIdx = _b[1];
+        var collection = currentState[collectionName].map(function (item, index) {
+            if (parseInt(collectionIdx, 10) === index) {
+                inCollection = true;
+                return action.payload;
+            }
+            return item;
+        });
+        if (inCollection === false) {
+            collection.splice(parseInt(collectionIdx, 10), 0, action.payload);
+        }
+        return Object.assign(currentState, (_a = {},
+            _a[collectionName] = collection,
+            _a));
+    },
+    themeItem: function (currentState, action) {
+        var store = {};
+        var nextStore = Object.assign(store, currentState);
+        var _a = action.payload, field = _a.field, value = _a.value;
+        var parts = field.split('.');
+        var key = parts.shift();
+        while (parts.length > 0) {
+            store = store[key] = store[key] || {};
+            key = parts.shift();
+        }
+        store[key] = value;
+        return nextStore;
+    }
+};
+export { optionsReducer, observersReducer };

package/dist/es/store/store.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @hidden
+ */
+export interface StoreAction {
+    mapKey?: string;
+    mapCollectionIdxKey?: string;
+    type?: string;
+    payload: any;
+}
+/**
+ * @hidden
+ */
+export interface Store {
+    getState(): any;
+    dispatch(action: StoreAction | object): void;
+    subscribe(f: Function): Function;
+}
+/**
+ * @hidden
+ */
+declare const createStore: (reducer: any) => Store;
+export default createStore;