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

package/dist/es/components/base/CollectionConfigurationComponent.js

@@ -0,0 +1,61 @@
+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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import * as React from 'react';
+import { MapContext } from '../../MapContext';
+/**
+ * @hidden
+ */
+var CollectionConfigurationComponent = /** @class */ (function (_super) {
+    __extends(CollectionConfigurationComponent, _super);
+    function CollectionConfigurationComponent(props, context) {
+        var _this = _super.call(this, props, context) || this;
+        _this.optionsStore = context.optionsStore;
+        return _this;
+    }
+    CollectionConfigurationComponent.prototype.renderChildren = function (child, index) {
+        var children = child.props.children;
+        var _a = this.props, _mapKey = _a._mapKey, _parentStore = _a._parentStore;
+        var collectionItemProps = __assign({}, child.props, { _mapCollectionIdxKey: _mapKey + "_" + index, _parentStore: _parentStore });
+        return React.cloneElement(child, collectionItemProps, children);
+    };
+    CollectionConfigurationComponent.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, _mapKey = _a._mapKey, _parentStore = _a._parentStore, children = _a.children;
+        var store = _parentStore || this.optionsStore;
+        store.dispatch({
+            mapKey: _mapKey,
+            payload: []
+        });
+        return React.Children.map(children, function (child, index) {
+            if (React.isValidElement(child)) {
+                return _this.renderChildren(child, index);
+            }
+            return child;
+        });
+    };
+    CollectionConfigurationComponent.contextType = MapContext;
+    return CollectionConfigurationComponent;
+}(React.Component));
+export default CollectionConfigurationComponent;

package/dist/es/components/base/ConfigurationComponent.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+/**
+ * @hidden
+ */
+export interface ConfigurationComponentProps {
+    _mapKey?: string;
+    _mapCollectionIdxKey?: string;
+    _parentStore?: any;
+    [x: string]: any;
+}
+/**
+ * @hidden
+ */
+export default class ConfigurationComponent extends React.Component<ConfigurationComponentProps> {
+    static contextType: React.Context<import("../../MapContext").MapContextType>;
+    optionsStore: any;
+    childStore: any;
+    constructor(props: any, context: any);
+    render(): any;
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    private dispatch;
+    private renderChildren;
+}

package/dist/es/components/base/ConfigurationComponent.js

@@ -0,0 +1,82 @@
+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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+import * as React from 'react';
+import createStore from './../../store/store';
+import { optionsReducer } from './../../store/reducer';
+import { MapContext } from '../../MapContext';
+/**
+ * @hidden
+ */
+var ConfigurationComponent = /** @class */ (function (_super) {
+    __extends(ConfigurationComponent, _super);
+    function ConfigurationComponent(props, context) {
+        var _this = _super.call(this, props, context) || this;
+        _this.optionsStore = context.optionsStore;
+        _this.childStore = createStore(optionsReducer);
+        return _this;
+    }
+    ConfigurationComponent.prototype.render = function () {
+        var _this = this;
+        var children = this.props.children;
+        return children !== undefined ? React.Children.map(children, function (child) {
+            if (React.isValidElement(child)) {
+                return _this.renderChildren(child);
+            }
+            return child;
+        }) : null;
+    };
+    ConfigurationComponent.prototype.componentDidMount = function () {
+        this.dispatch();
+    };
+    ConfigurationComponent.prototype.componentDidUpdate = function () {
+        this.dispatch();
+    };
+    ConfigurationComponent.prototype.dispatch = function () {
+        var _a = this.props, _mapKey = _a._mapKey, _mapCollectionIdxKey = _a._mapCollectionIdxKey, _parentStore = _a._parentStore, children = _a.children, options = __rest(_a, ["_mapKey", "_mapCollectionIdxKey", "_parentStore", "children"]);
+        var store = _parentStore || this.optionsStore;
+        store.dispatch({
+            mapKey: _mapKey,
+            mapCollectionIdxKey: _mapCollectionIdxKey,
+            payload: Object.assign({}, options, this.childStore.getState())
+        });
+    };
+    ConfigurationComponent.prototype.renderChildren = function (child) {
+        var children = child.props.children;
+        var configurationItemProps = __assign({}, child.props, { _parentStore: this.childStore });
+        return React.cloneElement(child, configurationItemProps, children);
+    };
+    ConfigurationComponent.contextType = MapContext;
+    return ConfigurationComponent;
+}(React.Component));
+export default ConfigurationComponent;

package/dist/es/components/main.d.ts

@@ -0,0 +1,6 @@
+import MapLayers, { MapLayersProps } from './Layers';
+import MapShapeLayer, { MapShapeLayerProps } from './ShapeLayer';
+import MapTileLayer, { MapTileLayerProps } from './TileLayer';
+import MapBubbleLayer, { MapBubbleLayerProps } from './BubbleLayer';
+import MapMarkerLayer, { MapMarkerLayerProps } from './MarkerLayer';
+export { MapLayers, MapLayersProps, MapShapeLayer, MapShapeLayerProps, MapTileLayer, MapTileLayerProps, MapBubbleLayer, MapBubbleLayerProps, MapMarkerLayer, MapMarkerLayerProps };

package/dist/es/components/main.js

@@ -0,0 +1,6 @@
+import MapLayers from './Layers';
+import MapShapeLayer from './ShapeLayer';
+import MapTileLayer from './TileLayer';
+import MapBubbleLayer from './BubbleLayer';
+import MapMarkerLayer from './MarkerLayer';
+export { MapLayers, MapShapeLayer, MapTileLayer, MapBubbleLayer, MapMarkerLayer };

package/dist/es/defaults.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/es/defaults.js

@@ -0,0 +1,15 @@
+import { DateCategoryAxis, DateValueAxis } from '@progress/kendo-charts';
+var dateCategoryAxisFormats = DateCategoryAxis.prototype.options.labels.dateFormats;
+var dateValueAxisFormats = DateValueAxis.prototype.options.labels.dateFormats;
+var dateFormats = {
+    milliseconds: 'HH:mm:ss.SSS',
+    seconds: { time: 'medium' },
+    minutes: { time: 'short' },
+    hours: { time: 'short' },
+    days: { skeleton: 'Md' },
+    weeks: { skeleton: 'Md' },
+    months: { skeleton: 'yyMMM' },
+    years: { skeleton: 'y' }
+};
+Object.assign(dateCategoryAxisFormats, dateFormats);
+Object.assign(dateValueAxisFormats, dateFormats);

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

@@ -0,0 +1,14 @@
+import { Map } from '../Map';
+/**
+ * @hidden
+ */
+export declare abstract class BaseEvent {
+    /**
+     * The `Map` component that triggered the event.
+     */
+    target: Map;
+    /**
+     * @hidden
+     */
+    constructor(target: Map);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @hidden
+ */
+var BaseEvent = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function BaseEvent(target) {
+        this.target = target;
+    }
+    return BaseEvent;
+}());
+export { BaseEvent };

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

@@ -0,0 +1,12 @@
+import { MapBeforeResetEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired immediately before the map is reset. This event is typically used for cleanup by layer implementers.
+ */
+export declare class BeforeResetEvent extends BaseEvent implements MapBeforeResetEvent {
+    /**
+     * @hidden
+     */
+    constructor(_: any, target: Map);
+}

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

@@ -0,0 +1,28 @@
+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 immediately before the map is reset. This event is typically used for cleanup by layer implementers.
+ */
+var BeforeResetEvent = /** @class */ (function (_super) {
+    __extends(BeforeResetEvent, _super);
+    /**
+     * @hidden
+     */
+    function BeforeResetEvent(_, target) {
+        return _super.call(this, target) || this;
+    }
+    return BeforeResetEvent;
+}(BaseEvent));
+export { BeforeResetEvent };

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

@@ -0,0 +1,20 @@
+import { Location, MapClickEvent as BaseMapClickEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when the user clicks on the map.
+ */
+export declare class MapClickEvent extends BaseEvent implements BaseMapClickEvent {
+    /**
+     * The location of the clicked point.
+     */
+    location: Location;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: BaseMapClickEvent, target: Map);
+}

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

@@ -0,0 +1,31 @@
+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 user clicks on the map.
+ */
+var MapClickEvent = /** @class */ (function (_super) {
+    __extends(MapClickEvent, _super);
+    /**
+     * @hidden
+     */
+    function MapClickEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.location = e.location;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return MapClickEvent;
+}(BaseEvent));
+export { MapClickEvent };

package/dist/es/events/map-event-builder.d.ts

@@ -0,0 +1,6 @@
+import { Map } from '../Map';
+/**
+ * @hidden
+ */
+declare function create(name: string, args: any, sender: Map): any;
+export { create };

package/dist/es/events/map-event-builder.js

@@ -0,0 +1,27 @@
+import { BeforeResetEvent, MapClickEvent, MarkerActivateEvent, MarkerClickEvent, MarkerCreatedEvent, PanEndEvent, PanEvent, ResetEvent, ShapeClickEvent, ShapeCreatedEvent, ShapeFeatureCreatedEvent, ShapeMouseEnterEvent, ShapeMouseLeaveEvent, ZoomEndEvent, ZoomStartEvent } from '../common/events';
+var EVENT_MAP = {
+    beforeReset: BeforeResetEvent,
+    mapClick: MapClickEvent,
+    markerActivate: MarkerActivateEvent,
+    markerClick: MarkerClickEvent,
+    markerCreated: MarkerCreatedEvent,
+    panEnd: PanEndEvent,
+    pan: PanEvent,
+    reset: ResetEvent,
+    shapeClick: ShapeClickEvent,
+    shapeCreated: ShapeCreatedEvent,
+    shapeFeatureCreated: ShapeFeatureCreatedEvent,
+    shapeMouseEnter: ShapeMouseEnterEvent,
+    shapeMouseLeave: ShapeMouseLeaveEvent,
+    zoomEnd: ZoomEndEvent,
+    zoomStart: ZoomStartEvent
+};
+/**
+ * @hidden
+ */
+function create(name, args, sender) {
+    if (EVENT_MAP[name]) {
+        return new EVENT_MAP[name](args, sender);
+    }
+}
+export { create };

package/dist/es/events/marker-activate-event.d.ts

@@ -0,0 +1,20 @@
+import { MapLayer, MapMarker, MapMarkerActivateEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a marker has been displayed and has a DOM element assigned.
+ */
+export declare class MarkerActivateEvent extends BaseEvent implements MapMarkerActivateEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerActivateEvent, target: Map);
+}

package/dist/es/events/marker-activate-event.js

@@ -0,0 +1,31 @@
+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 marker has been displayed and has a DOM element assigned.
+ */
+var MarkerActivateEvent = /** @class */ (function (_super) {
+    __extends(MarkerActivateEvent, _super);
+    /**
+     * @hidden
+     */
+    function MarkerActivateEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.marker = e.marker;
+        _this.layer = e.layer;
+        return _this;
+    }
+    return MarkerActivateEvent;
+}(BaseEvent));
+export { MarkerActivateEvent };

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

@@ -0,0 +1,20 @@
+import { MapLayer, MapMarker, MapMarkerClickEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired when a marker has been clicked or tapped.
+ */
+export declare class MarkerClickEvent extends BaseEvent implements MapMarkerClickEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerClickEvent, target: Map);
+}

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

@@ -0,0 +1,31 @@
+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 marker has been clicked or tapped.
+ */
+var MarkerClickEvent = /** @class */ (function (_super) {
+    __extends(MarkerClickEvent, _super);
+    /**
+     * @hidden
+     */
+    function MarkerClickEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.marker = e.marker;
+        _this.layer = e.layer;
+        return _this;
+    }
+    return MarkerClickEvent;
+}(BaseEvent));
+export { MarkerClickEvent };

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

@@ -0,0 +1,22 @@
+import { MapLayer, MapMarker, MapMarkerCreatedEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { PreventableEvent } from './preventable-event';
+/**
+ * Fired when a marker has been created and is about to be displayed.
+ *
+ * Cancelling the event will prevent the marker from being shown.
+ */
+export declare class MarkerCreatedEvent extends PreventableEvent implements MapMarkerCreatedEvent {
+    /**
+     * The marker instance.
+     */
+    marker: MapMarker;
+    /**
+     * The marker layer instance.
+     */
+    layer: MapLayer;
+    /**
+     * @hidden
+     */
+    constructor(e: MapMarkerCreatedEvent, target: Map);
+}

package/dist/es/events/marker-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 { PreventableEvent } from './preventable-event';
+/**
+ * Fired when a marker has been created and is about to be displayed.
+ *
+ * Cancelling the event will prevent the marker from being shown.
+ */
+var MarkerCreatedEvent = /** @class */ (function (_super) {
+    __extends(MarkerCreatedEvent, _super);
+    /**
+     * @hidden
+     */
+    function MarkerCreatedEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.marker = e.marker;
+        _this.layer = e.layer;
+        return _this;
+    }
+    return MarkerCreatedEvent;
+}(PreventableEvent));
+export { MarkerCreatedEvent };

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

@@ -0,0 +1,24 @@
+import { Location, MapPanEndEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fires after the map viewport has been moved.
+ */
+export declare class PanEndEvent extends BaseEvent implements MapPanEndEvent {
+    /**
+     * The map origin (top left or NW corner).
+     */
+    origin: Location;
+    /**
+     * The current map center.
+     */
+    center: Location;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapPanEndEvent, target: Map);
+}

package/dist/es/events/pan-end-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';
+/**
+ * Fires after the map viewport has been moved.
+ */
+var PanEndEvent = /** @class */ (function (_super) {
+    __extends(PanEndEvent, _super);
+    /**
+     * @hidden
+     */
+    function PanEndEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.origin = e.origin;
+        _this.center = e.center;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return PanEndEvent;
+}(BaseEvent));
+export { PanEndEvent };

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

@@ -0,0 +1,24 @@
+import { Location, MapPanEvent } from '@progress/kendo-charts';
+import { Map } from '../Map';
+import { BaseEvent } from './base-event';
+/**
+ * Fired while the map viewport is being moved.
+ */
+export declare class PanEvent extends BaseEvent implements MapPanEvent {
+    /**
+     * The map origin (top left or NW corner).
+     */
+    origin: Location;
+    /**
+     * The current map center.
+     */
+    center: Location;
+    /**
+     * The source DOM event instance
+     */
+    originalEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: MapPanEvent, target: Map);
+}

package/dist/es/events/pan-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 while the map viewport is being moved.
+ */
+var PanEvent = /** @class */ (function (_super) {
+    __extends(PanEvent, _super);
+    /**
+     * @hidden
+     */
+    function PanEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.origin = e.origin;
+        _this.center = e.center;
+        _this.originalEvent = e.originalEvent;
+        return _this;
+    }
+    return PanEvent;
+}(BaseEvent));
+export { PanEvent };

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

@@ -0,0 +1,18 @@
+import { BaseEvent } from './base-event';
+/**
+ * @hidden
+ */
+export declare abstract class PreventableEvent extends BaseEvent {
+    private prevented;
+    /**
+     * Prevents the default action for a specified event. In this way, the source component suppresses the built-in behavior that follows the event.
+     */
+    preventDefault(): void;
+    /**
+     * Returns `true` if the event was prevented by any of its subscribers.
+     *
+     * @returns `true` if the default action was prevented.
+     * Otherwise, returns `false`.
+     */
+    isDefaultPrevented(): boolean;
+}