mobility-toolbox-js 2.0.0-beta.34 → 2.0.0-beta.37

package/common/mixins/UserInteractionsLayerMixin.js

@@ -1,32 +1,14 @@
-"use strict";
-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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserInteractionsLayerInterface = void 0;
 /* eslint-disable no-empty-function,@typescript-eslint/no-empty-function */
 /* eslint-disable no-useless-constructor,@typescript-eslint/no-useless-constructor */
 /* eslint-disable no-unused-vars,@typescript-eslint/no-unused-vars */
 /* eslint-disable class-methods-use-this */
 /* eslint-disable max-classes-per-file */
-var proj_1 = require("ol/proj");
-var Observable_1 = require("ol/Observable");
+import { fromLonLat } from 'ol/proj';
+import { unByKey } from 'ol/Observable';
 /**
  * UserInteractionsLayerInterface.
  */
-var UserInteractionsLayerInterface = /** @class */ (function () {
+export class UserInteractionsLayerInterface {
     /*
      * Constructor
   
@@ -36,38 +18,34 @@ var UserInteractionsLayerInterface = /** @class */ (function () {
      * @param {string} options.userHoverInteractions If true, it listens for user mouse over event.
      * @param {string} options.defaultUserInteractions  If true, it adds default listeners for user mouse hover and click event.
      */
-    function UserInteractionsLayerInterface(options) {
-        if (options === void 0) { options = {}; }
-    }
+    constructor(options = {}) { }
     /**
      * Initialize the layer adding user interactions.
      *
      * @param {ol/Map~Map} map
      */
-    UserInteractionsLayerInterface.prototype.attachToMap = function (map) { };
+    attachToMap(map) { }
     /**
      * Terminate the layer unsubscribing user interactions.
      */
-    UserInteractionsLayerInterface.prototype.detachFromMap = function () { };
+    detachFromMap() { }
     /**
      * Activate map listeners events.
      */
-    UserInteractionsLayerInterface.prototype.activateUserInteractions = function () { };
+    activateUserInteractions() { }
     /**
      * Deactivaet map listeners events.
      */
-    UserInteractionsLayerInterface.prototype.deactivateUserInteractions = function () { };
+    deactivateUserInteractions() { }
     /**
      * Terminate the layer unsubscribing user interactions.
      */
-    UserInteractionsLayerInterface.prototype.onClick = function (callback) { };
+    onClick(callback) { }
     /**
      * Terminate the layer unsubscribing user interactions.
      */
-    UserInteractionsLayerInterface.prototype.onHover = function (callback) { };
-    return UserInteractionsLayerInterface;
-}());
-exports.UserInteractionsLayerInterface = UserInteractionsLayerInterface;
+    onHover(callback) { }
+}
 /**
  * Mixin for UserInteractionsLayerInterface. It provide onClick and onHover functions.
  *
@@ -75,151 +53,140 @@ exports.UserInteractionsLayerInterface = UserInteractionsLayerInterface;
  * @return {Class}  A class that implements {UserInteractionsLayerInterface} class and extends Base;
  * @private
  */
-var UserInteractionsLayerMixin = function (Base) {
-    return /** @class */ (function (_super) {
-        __extends(class_1, _super);
-        function class_1(options) {
-            if (options === void 0) { options = {}; }
-            var _this = _super.call(this, options) || this;
-            var _a = options.userInteractions, userInteractions = _a === void 0 ? true : _a, _b = options.userClickInteractions, userClickInteractions = _b === void 0 ? true : _b, _c = options.userHoverInteractions, userHoverInteractions = _c === void 0 ? true : _c, _d = options.defaultUserInteractions, defaultUserInteractions = _d === void 0 ? true : _d;
-            _this.userInteractions = userInteractions;
-            _this.userClickInteractions = userClickInteractions;
-            _this.userHoverInteractions = userHoverInteractions;
-            _this.defaultUserInteractions = defaultUserInteractions;
-            _this.userClickCallbacks = [];
-            _this.userHoverCallbacks = [];
-            _this.userClickEventsKeys = [];
-            _this.userHoverEventsKeys = [];
-            _this.onUserClickCallback = _this.onUserClickCallback.bind(_this);
-            _this.onUserMoveCallback = _this.onUserMoveCallback.bind(_this);
-            // Add mouse event callbacks
-            var onClick = options.onClick, onHover = options.onHover;
-            if (_this.userInteractions && _this.userClickInteractions && onClick) {
-                _this.onClick(onClick);
-            }
-            if (_this.userInteractions && _this.userHoverInteractions && onHover) {
-                _this.onHover(onHover);
-            }
-            return _this;
+const UserInteractionsLayerMixin = (Base) => class extends Base {
+    constructor(options = {}) {
+        super(options);
+        const { userInteractions = true, userClickInteractions = true, userHoverInteractions = true, defaultUserInteractions = true, } = options;
+        this.userInteractions = userInteractions;
+        this.userClickInteractions = userClickInteractions;
+        this.userHoverInteractions = userHoverInteractions;
+        this.defaultUserInteractions = defaultUserInteractions;
+        this.userClickCallbacks = [];
+        this.userHoverCallbacks = [];
+        this.userClickEventsKeys = [];
+        this.userHoverEventsKeys = [];
+        this.onUserClickCallback = this.onUserClickCallback.bind(this);
+        this.onUserMoveCallback = this.onUserMoveCallback.bind(this);
+        // Add mouse event callbacks
+        const { onClick, onHover } = options;
+        if (this.userInteractions && this.userClickInteractions && onClick) {
+            this.onClick(onClick);
+        }
+        if (this.userInteractions && this.userHoverInteractions && onHover) {
+            this.onHover(onHover);
+        }
+    }
+    attachToMap(map, options) {
+        super.attachToMap(map, options);
+        if (this.userInteractions &&
+            this.defaultUserInteractions &&
+            this.userClickInteractions &&
+            this.onFeatureClick) {
+            this.onClick(this.onFeatureClick);
         }
-        class_1.prototype.attachToMap = function (map, options) {
-            _super.prototype.attachToMap.call(this, map, options);
-            if (this.userInteractions &&
-                this.defaultUserInteractions &&
-                this.userClickInteractions &&
-                this.onFeatureClick) {
-                this.onClick(this.onFeatureClick);
-            }
-            if (this.userInteractions &&
-                this.defaultUserInteractions &&
-                this.userHoverInteractions &&
-                this.onFeatureHover) {
-                this.onHover(this.onFeatureHover);
-            }
+        if (this.userInteractions &&
+            this.defaultUserInteractions &&
+            this.userHoverInteractions &&
+            this.onFeatureHover) {
+            this.onHover(this.onFeatureHover);
+        }
+        this.listenEvents();
+    }
+    detachFromMap() {
+        this.unlistenEvents();
+        super.detachFromMap();
+    }
+    listenEvents() {
+        this.unlistenEvents();
+        this.userClickCallbacks.forEach((callback) => {
+            this.userClickEventsKeys.push(this.on('user:click', ({ target: { features, layer, coordinate } }) => {
+                callback(features, layer, coordinate);
+            }));
+        });
+        this.userHoverCallbacks.forEach((callback) => {
+            this.userHoverEventsKeys.push(this.on('user:hover', ({ target: { features, layer, coordinate, event } }) => {
+                callback(features, layer, coordinate, event);
+            }));
+        });
+    }
+    unlistenEvents() {
+        unByKey(this.userClickEventsKeys);
+        unByKey(this.userHoverEventsKeys);
+        this.userClickEventsKeys = [];
+        this.userHoverEventsKeys = [];
+    }
+    /**
+     * Listens to click events on the layer.
+     * @param {function} callback Callback function, called with the clicked
+     *   features,
+     *   the layer instance and the click event.
+     */
+    onClick(callback) {
+        this.userClickCallbacks.push(callback);
+        this.activateUserInteractions();
+        if (this.map) {
+            // If the layer is already attached to the map we reload the events
             this.listenEvents();
+        }
+    }
+    /**
+     * Listens to hover events on the layer.
+     * @param {function} callback Callback function, called with the clicked
+     *   features, the layer instance and the click event.
+     */
+    onHover(callback) {
+        this.userHoverCallbacks.push(callback);
+        this.activateUserInteractions();
+        if (this.map) {
+            // If the layer is already attached to the map we reload the events
+            this.listenEvents();
+        }
+    }
+    /**
+     * Function triggered when the user click the map.
+     * @private
+     */
+    onUserClickCallback(evt) {
+        const coordinate = evt.coordinate || fromLonLat(evt.lngLat.toArray());
+        const emptyFeatureInfo = {
+            features: [],
+            layer: this,
+            coordinate,
+            event: evt,
         };
-        class_1.prototype.detachFromMap = function () {
-            this.unlistenEvents();
-            _super.prototype.detachFromMap.call(this);
-        };
-        class_1.prototype.listenEvents = function () {
-            var _this = this;
-            this.unlistenEvents();
-            this.userClickCallbacks.forEach(function (callback) {
-                _this.userClickEventsKeys.push(_this.on('user:click', function (_a) {
-                    var _b = _a.target, features = _b.features, layer = _b.layer, coordinate = _b.coordinate;
-                    callback(features, layer, coordinate);
-                }));
-            });
-            this.userHoverCallbacks.forEach(function (callback) {
-                _this.userHoverEventsKeys.push(_this.on('user:hover', function (_a) {
-                    var _b = _a.target, features = _b.features, layer = _b.layer, coordinate = _b.coordinate, event = _b.event;
-                    callback(features, layer, coordinate, event);
-                }));
+        return this.getFeatureInfoAtCoordinate(coordinate)
+            .then((featureInfo) => {
+            this.dispatchEvent({
+                type: 'user:click',
+                target: featureInfo,
             });
+            return featureInfo;
+        })
+            .catch(() => emptyFeatureInfo);
+    }
+    /**
+     * Function triggered when the user move the cursor.
+     * @private
+     */
+    onUserMoveCallback(evt) {
+        const coordinate = evt.coordinate || fromLonLat(evt.lngLat.toArray());
+        const emptyFeatureInfo = {
+            features: [],
+            layer: this,
+            coordinate,
+            event: evt,
         };
-        class_1.prototype.unlistenEvents = function () {
-            (0, Observable_1.unByKey)(this.userClickEventsKeys);
-            (0, Observable_1.unByKey)(this.userHoverEventsKeys);
-            this.userClickEventsKeys = [];
-            this.userHoverEventsKeys = [];
-        };
-        /**
-         * Listens to click events on the layer.
-         * @param {function} callback Callback function, called with the clicked
-         *   features,
-         *   the layer instance and the click event.
-         */
-        class_1.prototype.onClick = function (callback) {
-            this.userClickCallbacks.push(callback);
-            this.activateUserInteractions();
-            if (this.map) {
-                // If the layer is already attached to the map we reload the events
-                this.listenEvents();
-            }
-        };
-        /**
-         * Listens to hover events on the layer.
-         * @param {function} callback Callback function, called with the clicked
-         *   features, the layer instance and the click event.
-         */
-        class_1.prototype.onHover = function (callback) {
-            this.userHoverCallbacks.push(callback);
-            this.activateUserInteractions();
-            if (this.map) {
-                // If the layer is already attached to the map we reload the events
-                this.listenEvents();
-            }
-        };
-        /**
-         * Function triggered when the user click the map.
-         * @private
-         */
-        class_1.prototype.onUserClickCallback = function (evt) {
-            var _this = this;
-            var coordinate = evt.coordinate || (0, proj_1.fromLonLat)(evt.lngLat.toArray());
-            var emptyFeatureInfo = {
-                features: [],
-                layer: this,
-                coordinate: coordinate,
-                event: evt,
-            };
-            return this.getFeatureInfoAtCoordinate(coordinate)
-                .then(function (featureInfo) {
-                _this.dispatchEvent({
-                    type: 'user:click',
-                    target: featureInfo,
-                });
-                return featureInfo;
-            })
-                .catch(function () { return emptyFeatureInfo; });
-        };
-        /**
-         * Function triggered when the user move the cursor.
-         * @private
-         */
-        class_1.prototype.onUserMoveCallback = function (evt) {
-            var _this = this;
-            var coordinate = evt.coordinate || (0, proj_1.fromLonLat)(evt.lngLat.toArray());
-            var emptyFeatureInfo = {
-                features: [],
-                layer: this,
-                coordinate: coordinate,
-                event: evt,
-            };
-            return this.getFeatureInfoAtCoordinate(coordinate)
-                .then(function (featureInfo) {
-                _this.dispatchEvent({
-                    type: 'user:hover',
-                    target: featureInfo,
-                });
-                return featureInfo;
-            })
-                .catch(function () { return emptyFeatureInfo; });
-        };
-        class_1.prototype.activateUserInteractions = function () { };
-        class_1.prototype.deactivateUserInteractions = function () { };
-        return class_1;
-    }(Base));
+        return this.getFeatureInfoAtCoordinate(coordinate)
+            .then((featureInfo) => {
+            this.dispatchEvent({
+                type: 'user:hover',
+                target: featureInfo,
+            });
+            return featureInfo;
+        })
+            .catch(() => emptyFeatureInfo);
+    }
+    activateUserInteractions() { }
+    deactivateUserInteractions() { }
 };
-exports.default = UserInteractionsLayerMixin;
+export default UserInteractionsLayerMixin;

package/common/mixins/UserInteractionsLayerMixin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=UserInteractionsLayerMixin.test.d.ts.map

package/common/mixins/UserInteractionsLayerMixin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserInteractionsLayerMixin.test.d.ts","sourceRoot":"","sources":["../../../src/common/mixins/UserInteractionsLayerMixin.test.js"],"names":[],"mappings":""}

package/common/mixins/UserInteractionsLayerMixin.test.js

@@ -0,0 +1,214 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import BaseLayer from '../layers/Layer';
+import mixin from './UserInteractionsLayerMixin';
+const olLayer = new VectorLayer({ source: new VectorSource() });
+const Layer = mixin(BaseLayer);
+describe('Layer', () => {
+    test('should initialize.', () => {
+        const layer = new Layer();
+        expect(layer).toBeInstanceOf(Layer);
+    });
+    test('should define default properties.', () => {
+        const layer = new Layer();
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.userInteractions).toEqual(true);
+        expect(layer.userClickInteractions).toEqual(true);
+        expect(layer.userHoverInteractions).toEqual(true);
+        expect(layer.defaultUserInteractions).toBe(true);
+        expect(layer.userClickCallbacks).toEqual([]);
+        expect(layer.userHoverCallbacks).toEqual([]);
+        expect(layer.userClickEventsKeys).toEqual([]);
+        expect(layer.userHoverEventsKeys).toEqual([]);
+    });
+    test('should set userInteractionsXXX to false.', () => {
+        const options = {
+            userInteractions: false,
+            userClickInteractions: false,
+            userHoverInteractions: false,
+            defaultUserInteractions: false,
+        };
+        const layer = new Layer(options);
+        expect(layer).toBeInstanceOf(Layer);
+        expect(layer.userInteractions).toBe(false);
+        expect(layer.userClickInteractions).toBe(false);
+        expect(layer.userHoverInteractions).toBe(false);
+        expect(layer.defaultUserInteractions).toBe(false);
+    });
+    test('should set onClick using constructor', () => {
+        const fn = () => { };
+        const layer = new Layer({
+            onClick: fn,
+            onHover: fn,
+        });
+        expect(layer.userClickCallbacks[0]).toBe(fn);
+        expect(layer.userHoverCallbacks[0]).toBe(fn);
+        expect(layer.userClickEventsKeys.length).toBe(0);
+        expect(layer.userHoverEventsKeys.length).toBe(0);
+    });
+    describe('#attachToMap()', () => {
+        test('should not add events if no callbacks', () => {
+            const layer = new Layer({
+                olLayer,
+            });
+            expect(layer.map).toBe(undefined);
+            const obj = {};
+            layer.attachToMap(obj);
+            expect(layer.userClickEventsKeys.length).toBe(0);
+            expect(layer.userHoverEventsKeys.length).toBe(0);
+        });
+        test('should add events', () => {
+            const fn = () => { };
+            const layer = new Layer({
+                olLayer,
+                onClick: fn,
+                onHover: fn,
+            });
+            expect(layer.map).toBe(undefined);
+            const obj = {};
+            layer.attachToMap(obj);
+            expect(layer.userClickEventsKeys.length).toBe(1);
+            expect(layer.userHoverEventsKeys.length).toBe(1);
+        });
+    });
+    describe('#onClick()', () => {
+        test('adds function to callback array', () => {
+            const layer = new Layer();
+            const fn = jest.fn();
+            const fn2 = jest.fn();
+            layer.onClick(fn);
+            expect(layer.userClickCallbacks).toEqual([fn]);
+            layer.onClick(fn2);
+            expect(layer.userClickCallbacks).toEqual([fn, fn2]);
+            expect(layer.userClickEventsKeys.length).toBe(0);
+            layer.attachToMap({});
+            expect(layer.userClickEventsKeys.length).toBe(2);
+        });
+    });
+    describe('#onHover()', () => {
+        test('adds function to callback array', () => {
+            const layer = new Layer();
+            const fn = jest.fn();
+            const fn2 = jest.fn();
+            layer.onHover(fn);
+            expect(layer.userHoverCallbacks).toEqual([fn]);
+            layer.onHover(fn2);
+            expect(layer.userHoverCallbacks).toEqual([fn, fn2]);
+            expect(layer.userHoverEventsKeys.length).toBe(0);
+            layer.attachToMap({});
+            expect(layer.userHoverEventsKeys.length).toBe(2);
+        });
+    });
+    describe('#onUserClickCallback()', () => {
+        const evt = { type: 'signleclick', coordinate: [0, 0] };
+        const getFeatureInfo = (layer, features = []) => ({
+            features,
+            layer,
+            coordinate: evt.coordinate,
+            event: evt,
+        });
+        test('calls click callback functions', (done) => __awaiter(void 0, void 0, void 0, function* () {
+            const layer = new Layer();
+            const goodFeatureInfo = getFeatureInfo(layer, [{ name: 'test' }]);
+            const fn = jest.fn();
+            const fn2 = jest.fn();
+            const spy = jest
+                .spyOn(layer, 'getFeatureInfoAtCoordinate')
+                .mockResolvedValue(goodFeatureInfo);
+            layer.onClick(fn);
+            layer.onClick(fn2);
+            layer.attachToMap({});
+            layer.onUserClickCallback(evt).then((featureInfo) => {
+                expect(spy).toHaveBeenCalledTimes(1);
+                expect(spy).toHaveBeenCalledWith(evt.coordinate);
+                expect(featureInfo).toBe(goodFeatureInfo);
+                expect(fn).toHaveBeenCalledTimes(1);
+                expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
+                expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
+                expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
+                expect(fn2).toHaveBeenCalledTimes(1);
+                expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
+                expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
+                expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
+                done();
+            });
+        }));
+        describe('returns empty feature info', () => {
+            test('if an error is thrown in click callback', (done) => {
+                const layer = new Layer();
+                layer.onClick(() => {
+                    throw new Error('foo');
+                });
+                const goodFeatureInfo = getFeatureInfo(layer, [{ name: 'test' }]);
+                jest
+                    .spyOn(layer, 'getFeatureInfoAtCoordinate')
+                    .mockResolvedValue(goodFeatureInfo);
+                layer.attachToMap({});
+                layer.onUserClickCallback(evt).then((featureInfo) => {
+                    expect(featureInfo).toEqual(getFeatureInfo(layer));
+                    done();
+                });
+            });
+        });
+    });
+    describe('#onUserMoveCallback()', () => {
+        const evt = { type: 'pointermove', coordinate: [0, 0] };
+        const getFeatureInfo = (layer, features = []) => ({
+            features,
+            layer,
+            coordinate: evt.coordinate,
+            event: evt,
+        });
+        test('calls hover callback functions', (done) => {
+            const layer = new Layer();
+            const goodFeatureInfo = getFeatureInfo(layer, [{ name: 'test' }]);
+            const fn = jest.fn();
+            const fn2 = jest.fn();
+            const spy = jest
+                .spyOn(layer, 'getFeatureInfoAtCoordinate')
+                .mockResolvedValue(goodFeatureInfo);
+            layer.onHover(fn);
+            layer.onHover(fn2);
+            layer.attachToMap({});
+            layer.onUserMoveCallback(evt).then((featureInfo) => {
+                expect(spy).toHaveBeenCalledTimes(1);
+                expect(spy).toHaveBeenCalledWith(evt.coordinate);
+                expect(featureInfo).toBe(goodFeatureInfo);
+                expect(fn).toHaveBeenCalledTimes(1);
+                expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
+                expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
+                expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
+                expect(fn2).toHaveBeenCalledTimes(1);
+                expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
+                expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
+                expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
+                done();
+            });
+        });
+        describe('returns empty feature info', () => {
+            test('if an error is thrown in hover callback', (done) => {
+                const layer = new Layer();
+                layer.onHover(() => {
+                    throw new Error('foo');
+                });
+                jest
+                    .spyOn(layer, 'getFeatureInfoAtCoordinate')
+                    .mockResolvedValue(getFeatureInfo(layer, [{ name: 'test' }]));
+                layer.attachToMap({});
+                layer.onUserMoveCallback(evt).then((featureInfo) => {
+                    expect(featureInfo).toEqual(getFeatureInfo(layer));
+                    done();
+                });
+            });
+        });
+    });
+});

package/common/styles/index.js

@@ -1,24 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.realtimeSimpleStyle = exports.realtimeDelayStyle = exports.realtimeDefaultStyle = void 0;
-var realtimeDefaultStyle_1 = require("./realtimeDefaultStyle");
-Object.defineProperty(exports, "realtimeDefaultStyle", { enumerable: true, get: function () { return realtimeDefaultStyle_1.default; } });
-var realtimeDelayStyle_1 = require("./realtimeDelayStyle");
-Object.defineProperty(exports, "realtimeDelayStyle", { enumerable: true, get: function () { return realtimeDelayStyle_1.default; } });
-var realtimeSimpleStyle_1 = require("./realtimeSimpleStyle");
-Object.defineProperty(exports, "realtimeSimpleStyle", { enumerable: true, get: function () { return realtimeSimpleStyle_1.default; } });
-__exportStar(require("./realtimeDefaultStyle"), exports);
+export { default as realtimeDefaultStyle } from './realtimeDefaultStyle';
+export { default as realtimeDelayStyle } from './realtimeDelayStyle';
+export { default as realtimeSimpleStyle } from './realtimeSimpleStyle';
+export * from './realtimeDefaultStyle';

package/common/styles/realtimeDefaultStyle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realtimeDefaultStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeDefaultStyle.js"],"names":[],"mappings":"AAUO,4EAeN;AAUM,2JA2BN;AAUM,0HAoCN;AAUM,6IAuCN;;AAKD;;;;;;;GAOG;AACH,0FAgMC"}
+{"version":3,"file":"realtimeDefaultStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeDefaultStyle.js"],"names":[],"mappings":"AAUO,4EAeN;AAUM,2JA2BN;AAUM,0HAoCN;AAUM,6IAuCN;;AAKD;;;;;;;GAOG;AACH,0FA8LC"}