@map-colonies/react-components 3.8.1 → 3.10.2

package/dist/cesium-map/tools/geojson/geojson-to-primitive.d.ts

@@ -0,0 +1,4 @@
+import { FeatureCollection } from 'geojson';
+import { PrimitiveCoordinates } from '../../data-sources';
+import { DrawType } from '../../../models/enums';
+export declare const geoJSONToPrimitive: (type: DrawType, geojson: FeatureCollection) => PrimitiveCoordinates | never;

package/dist/cesium-map/tools/geojson/geojson-to-primitive.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geoJSONToPrimitive = void 0;
+var cesium_1 = require("cesium");
+var lodash_1 = require("lodash");
+var enums_1 = require("../../../models/enums");
+var POINTS_NUM = 2;
+var geoJSONToPrimitive = function (type, geojson) {
+    switch (type) {
+        case enums_1.DrawType.BOX: {
+            if (geojson.features.length !== POINTS_NUM)
+                throw new Error(type + " must have 2 points");
+            var bottomLeftPoint = lodash_1.find(geojson.features, function (feat) {
+                var _a;
+                return ((_a = feat.properties) === null || _a === void 0 ? void 0 : _a.type) === enums_1.BboxCorner.BOTTOM_LEFT;
+            });
+            var rightTopPoint = lodash_1.find(geojson.features, function (feat) {
+                var _a;
+                return ((_a = feat.properties) === null || _a === void 0 ? void 0 : _a.type) === enums_1.BboxCorner.TOP_RIGHT;
+            });
+            // eslint-disable-next-line
+            if (rightTopPoint && bottomLeftPoint) {
+                if (bottomLeftPoint.geometry.coordinates[0] ===
+                    rightTopPoint.geometry.coordinates[0] &&
+                    bottomLeftPoint.geometry.coordinates[1] ===
+                        rightTopPoint.geometry.coordinates[1]) {
+                    throw new Error(type + " must define BOTTOM_LEFT and TOP_RIGHT different points");
+                }
+                else {
+                    return cesium_1.Rectangle.fromDegrees(bottomLeftPoint.geometry.coordinates[0], bottomLeftPoint.geometry.coordinates[1], rightTopPoint.geometry.coordinates[0], rightTopPoint.geometry.coordinates[1]);
+                }
+            }
+            else {
+                throw new Error(type + " geojson must define BOTTOM_LEFT and TOP_RIGHT points");
+            }
+        }
+        default:
+            throw new Error(type + " type geoJSON still not supported");
+    }
+};
+exports.geoJSONToPrimitive = geoJSONToPrimitive;

package/dist/cesium-map/tools/geojson/index.d.ts

@@ -0,0 +1,2 @@
+export * from './polygon.geojson';
+export * from './rectangle.geojson';

package/dist/cesium-map/tools/geojson/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 });
+__exportStar(require("./polygon.geojson"), exports);
+__exportStar(require("./rectangle.geojson"), exports);

package/dist/cesium-map/tools/geojson/point.geojson.d.ts

@@ -0,0 +1,3 @@
+import { GeoJSON } from 'geojson';
+import { CesiumViewer } from '../../map';
+export declare const pointToGeoJSON: (mapViewer: CesiumViewer, x: number, y: number) => GeoJSON;

package/dist/cesium-map/tools/geojson/point.geojson.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointToGeoJSON = void 0;
+var cesium_1 = require("cesium");
+var pointToGeoJSON = function (mapViewer, x, y) {
+    var ellipsoid = mapViewer.scene.globe.ellipsoid;
+    var cartesian = mapViewer.camera.pickEllipsoid(new cesium_1.Cartesian3(x, y), ellipsoid);
+    var cartographic = ellipsoid.cartesianToCartographic(cartesian);
+    return {
+        type: 'Feature',
+        properties: {},
+        geometry: {
+            type: 'Point',
+            coordinates: [
+                cesium_1.Math.toDegrees(cartographic.longitude),
+                cesium_1.Math.toDegrees(cartographic.latitude),
+            ],
+        },
+    };
+};
+exports.pointToGeoJSON = pointToGeoJSON;

package/dist/cesium-map/tools/geojson/polygon.geojson.d.ts

@@ -0,0 +1,3 @@
+import { Cartesian3 } from 'cesium';
+import { GeoJSON } from 'geojson';
+export declare const polygonToGeoJSON: (positions: Cartesian3[]) => GeoJSON;

package/dist/cesium-map/tools/geojson/polygon.geojson.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polygonToGeoJSON = void 0;
+var cesium_1 = require("cesium");
+var polygonToGeoJSON = function (positions) {
+    var coords = positions.map(function (vertex) {
+        var posRadians = cesium_1.Cartographic.fromCartesian(vertex);
+        return [
+            cesium_1.Math.toDegrees(posRadians.longitude),
+            cesium_1.Math.toDegrees(posRadians.latitude),
+        ];
+    });
+    // close polygon
+    coords.push(coords[0]);
+    return {
+        type: 'Feature',
+        properties: {},
+        geometry: {
+            type: 'Polygon',
+            coordinates: [coords],
+        },
+    };
+};
+exports.polygonToGeoJSON = polygonToGeoJSON;

package/dist/cesium-map/tools/geojson/rectangle.geojson.d.ts

@@ -0,0 +1,3 @@
+import { Rectangle } from 'cesium';
+import { GeoJSON } from 'geojson';
+export declare const rectangleToGeoJSON: (positions: Rectangle) => GeoJSON;

package/dist/cesium-map/tools/geojson/rectangle.geojson.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rectangleToGeoJSON = void 0;
+var cesium_1 = require("cesium");
+var turf = __importStar(require("@turf/helpers"));
+var bbox_1 = __importDefault(require("@turf/bbox"));
+var bbox_polygon_1 = __importDefault(require("@turf/bbox-polygon"));
+var rectangleToGeoJSON = function (positions) {
+    var line = turf.lineString([
+        [
+            cesium_1.Math.toDegrees(positions.west),
+            cesium_1.Math.toDegrees(positions.south),
+        ],
+        [
+            cesium_1.Math.toDegrees(positions.east),
+            cesium_1.Math.toDegrees(positions.north),
+        ],
+    ]);
+    var polygon = bbox_polygon_1.default(bbox_1.default(line));
+    return polygon;
+};
+exports.rectangleToGeoJSON = rectangleToGeoJSON;

package/dist/cesium-map/tools/inspector.tool.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export interface InspectorProps {
+}
+export declare const InspectorTool: React.FC<InspectorProps>;

package/dist/cesium-map/tools/inspector.tool.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectorTool = void 0;
+var react_1 = __importStar(require("react"));
+var cesium_1 = require("cesium");
+var map_1 = require("../map");
+var InspectorTool = function (props) {
+    var mapViewer = map_1.useCesiumMap();
+    react_1.useEffect(function () {
+        mapViewer.extend(cesium_1.viewerCesiumInspectorMixin);
+    }, [mapViewer]);
+    return react_1.default.createElement(react_1.default.Fragment, null);
+};
+exports.InspectorTool = InspectorTool;

package/dist/cesium-map/tools/scale-tracker.tool.css

@@ -0,0 +1,16 @@
+.scalePosition {
+  background-color: var(--mdc-theme-surface);
+  padding: 1px 1px;
+  border-radius: 2px;
+  font-size: 12px;
+  width: 110px;
+}
+.distance-legend-label {
+  text-align: center;
+}
+.distance-legend-scale-bar {
+  background: var(--mdc-theme-on-surface);
+  margin: 0 auto;
+  display: block;
+  transition: all 0.5s ease-in-out;
+}

package/dist/cesium-map/tools/scale-tracker.tool.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import './scale-tracker.tool.css';
+export interface RScaleTrackerToolProps {
+    locale?: {
+        [key: string]: string;
+    };
+}
+export declare const ScaleTrackerTool: React.FC<RScaleTrackerToolProps>;

package/dist/cesium-map/tools/scale-tracker.tool.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleTrackerTool = void 0;
+var react_1 = __importStar(require("react"));
+var cesium_1 = require("cesium");
+var lodash_1 = require("lodash");
+var map_1 = require("../map");
+require("./scale-tracker.tool.css");
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+var distances = [
+    1,
+    2,
+    3,
+    5,
+    10,
+    20,
+    30,
+    50,
+    100,
+    200,
+    300,
+    500,
+    1000,
+    2000,
+    3000,
+    5000,
+    10000,
+    20000,
+    30000,
+    50000,
+    100000,
+    200000,
+    300000,
+    500000,
+    1000000,
+    2000000,
+    3000000,
+    5000000,
+    10000000,
+    20000000,
+    30000000,
+    50000000,
+];
+var updateDistanceLegendCesium = function (mapViewer, prevScaleData, setScaleData, locale) {
+    var _a, _b;
+    var metersUnit = (_a = lodash_1.get(locale, 'METERS_UNIT')) !== null && _a !== void 0 ? _a : 'm';
+    var kiloMetersUnit = (_b = lodash_1.get(locale, 'KILOMETERS_UNIT')) !== null && _b !== void 0 ? _b : 'km';
+    var scale = {
+        barWidth: undefined,
+        distanceLabel: undefined,
+        lastLegendUpdate: prevScaleData.lastLegendUpdate,
+    };
+    var geodesic = new cesium_1.EllipsoidGeodesic();
+    var now = new Date().getTime();
+    if (now < scale.lastLegendUpdate + 250) {
+        return;
+    }
+    scale.lastLegendUpdate = now;
+    // Find the distance between two pixels at the bottom center of the screen.
+    var width = mapViewer.scene.canvas.clientWidth;
+    var height = mapViewer.scene.canvas.clientHeight;
+    var left = mapViewer.scene.camera.getPickRay(new cesium_1.Cartesian2((width / 2) | 0, height - 1));
+    var right = mapViewer.scene.camera.getPickRay(new cesium_1.Cartesian2((1 + width / 2) | 0, height - 1));
+    var globe = mapViewer.scene.globe;
+    var leftPosition = globe.pick(left, mapViewer.scene);
+    var rightPosition = globe.pick(right, mapViewer.scene);
+    if (!leftPosition || !rightPosition) {
+        return;
+    }
+    var leftCartographic = globe.ellipsoid.cartesianToCartographic(leftPosition);
+    var rightCartographic = globe.ellipsoid.cartesianToCartographic(rightPosition);
+    geodesic.setEndPoints(leftCartographic, rightCartographic);
+    var pixelDistance = geodesic.surfaceDistance;
+    // Find the first distance that makes the scale bar less than 100 pixels.
+    var maxBarWidth = 100;
+    var distance;
+    for (var i = distances.length - 1; !lodash_1.isNumber(distance) && i >= 0; --i) {
+        if (distances[i] / pixelDistance < maxBarWidth) {
+            distance = distances[i];
+        }
+    }
+    if (lodash_1.isNumber(distance)) {
+        var label = '';
+        if (distance >= 1000) {
+            label = (distance / 1000).toString() + " " + kiloMetersUnit;
+        }
+        else {
+            label = distance.toString() + " " + metersUnit;
+        }
+        scale.barWidth = (distance / pixelDistance) | 0;
+        scale.distanceLabel = label;
+    }
+    setScaleData(scale);
+};
+/* eslint-enable @typescript-eslint/no-magic-numbers */
+var ScaleTrackerTool = function (props) {
+    var mapViewer = map_1.useCesiumMap();
+    var _a = react_1.useState({
+        barWidth: undefined,
+        distanceLabel: undefined,
+        lastLegendUpdate: -1,
+    }), scaleData = _a[0], setScaleData = _a[1];
+    react_1.useEffect(function () {
+        var setFromEvent = function (e) {
+            updateDistanceLegendCesium(mapViewer, scaleData, setScaleData, props.locale);
+        };
+        var helper = new cesium_1.EventHelper();
+        var tileLoadHandler = function (event) {
+            if (mapViewer.scene.globe.tilesLoaded) {
+                setFromEvent(new MouseEvent('mouse'));
+                helper.removeAll();
+            }
+        };
+        // Register tiles loader handler for initial load because globe.pick returning undefined
+        // see here https://community.cesium.com/t/globe-pick-returning-undefined/6616
+        helper.add(mapViewer.scene.globe.tileLoadProgressEvent, tileLoadHandler);
+        mapViewer.camera.moveEnd.addEventListener(setFromEvent);
+        return function () {
+            try {
+                mapViewer.camera.moveEnd.removeEventListener(setFromEvent);
+            }
+            catch (e) {
+                console.log('CESIUM camera "moveEnd" remove listener failed', e);
+            }
+        };
+    }, [mapViewer, props.locale, scaleData]);
+    var calcLeft = function (width) {
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        return 5 + (125 - width) / 2;
+    };
+    return (react_1.default.createElement("div", { className: "scalePosition" }, lodash_1.isNumber(scaleData.barWidth) && (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement("div", { className: "distance-legend-label" }, scaleData.distanceLabel),
+        react_1.default.createElement("div", { className: "distance-legend-scale-bar", style: {
+                height: '2px',
+                width: scaleData.barWidth.toString() + "px",
+                left: calcLeft(scaleData.barWidth).toString() + "px",
+            } })))));
+};
+exports.ScaleTrackerTool = ScaleTrackerTool;

package/dist/cesium-map/tools/terranian-height.tool.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export interface TerrainianHeightProps {
+}
+export declare const TerrainianHeightTool: React.FC<TerrainianHeightProps>;

package/dist/cesium-map/tools/terranian-height.tool.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerrainianHeightTool = void 0;
+var react_1 = __importDefault(require("react"));
+var cesium_1 = require("cesium");
+var map_1 = require("../map");
+var LABEL_PIXEL_OFFSET = -25;
+var FIRST_DATA_ROW_IDX = 2;
+var TerrainianHeightTool = function (props) {
+    var mapViewer = map_1.useCesiumMap();
+    var csvToArray = function (str, delimiter) {
+        if (delimiter === void 0) { delimiter = ','; }
+        // const headers = str.slice(0, str.indexOf('\n')).split(delimiter);
+        var rows = str.slice(str.indexOf('\n') + 1).split('\n');
+        var arr = rows.map(function (row) {
+            var values = row.split(delimiter);
+            var el = cesium_1.Cartographic.fromDegrees(parseFloat(values[0]), parseFloat(values[1]));
+            // const el = headers.reduce((object: Record<string, number>, header, index) => {
+            //   const trimmedHeader = header.trim();
+            //   object[trimmedHeader] = parseFloat(values[index]);
+            //   return object;
+            // }, {});
+            //return el;
+            return {
+                cartographic: el,
+                cartesian: new cesium_1.Cartesian2(parseFloat(values[0]), parseFloat(values[1])),
+            };
+        });
+        return arr;
+    };
+    var loadCSV = function (evt) {
+        var _a;
+        evt.preventDefault();
+        evt.persist();
+        var reader = new FileReader();
+        reader.onload = function (e) {
+            var _a;
+            var text = (_a = e.target) === null || _a === void 0 ? void 0 : _a.result;
+            var parsed = csvToArray(text);
+            var ellipsoid = cesium_1.Ellipsoid.WGS84;
+            console.log('Loaded CSV content:\n', text);
+            void cesium_1.sampleTerrainMostDetailed(mapViewer.terrainProvider, parsed.map(function (item) { return item.cartographic; })).then(function (updatedPositions) {
+                console.log(updatedPositions);
+                mapViewer.scene.globe.depthTestAgainstTerrain = true;
+                mapViewer.entities.suspendEvents();
+                mapViewer.entities.removeAll();
+                updatedPositions.forEach(function (position, idx) {
+                    mapViewer.entities.add({
+                        name: (idx + FIRST_DATA_ROW_IDX).toString(),
+                        position: ellipsoid.cartographicToCartesian(position),
+                        billboard: {
+                            verticalOrigin: cesium_1.VerticalOrigin.BOTTOM,
+                            scale: 0.7,
+                            image: 'assets/img/map-marker.gif',
+                        },
+                        label: {
+                            text: (idx + FIRST_DATA_ROW_IDX).toString(),
+                            font: '14pt monospace',
+                            fillColor: cesium_1.Color.BLACK,
+                            style: cesium_1.LabelStyle.FILL_AND_OUTLINE,
+                            outlineWidth: 4,
+                            outlineColor: cesium_1.Color.BLACK,
+                            verticalOrigin: cesium_1.VerticalOrigin.BOTTOM,
+                            pixelOffset: new cesium_1.Cartesian2(0, LABEL_PIXEL_OFFSET),
+                        },
+                        description: "\n                Long: " + parsed[idx].cartesian.x + " </br>\n                Lat: " + parsed[idx].cartesian.y + " </br>\n                Height(m): <span style=\"font-weight: 500\">" + position.height + "</span>\n              ",
+                    });
+                });
+                mapViewer.entities.resumeEvents();
+                if (evt.target.files !== null) {
+                    exportToCsv("terranian_heights_" + evt.target.files[0].name, parsed);
+                    evt.target.value = '';
+                }
+                console.log('Pinned point count is ', mapViewer.entities.values.length);
+            }, function (err) {
+                console.error('ERROR while sampleTerrainMostDetailed:', err);
+            });
+        };
+        if ((_a = evt.target.files) === null || _a === void 0 ? void 0 : _a[0]) {
+            reader.readAsText(evt.target.files[0]);
+        }
+    };
+    var exportToCsv = function (filename, rows) {
+        var processRow = function (row) {
+            var finalVal = '';
+            finalVal += row.cartesian.x.toString() + ',';
+            finalVal += row.cartesian.y.toString() + ',';
+            finalVal += row.cartographic.height.toString();
+            return finalVal + '\n';
+        };
+        var csvFile = 'long,lat,height\n';
+        rows.forEach(function (row) {
+            csvFile += processRow(row);
+        });
+        var blob = new Blob([csvFile], { type: 'text/csv;charset=utf-8;' });
+        var link = document.createElement('a');
+        var url = URL.createObjectURL(blob);
+        link.setAttribute('href', url);
+        link.setAttribute('download', filename);
+        link.style.visibility = 'hidden';
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    };
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement("input", { type: "file", id: "csvFile", accept: ".csv", onChange: function (e) {
+                loadCSV(e);
+            } })));
+};
+exports.TerrainianHeightTool = TerrainianHeightTool;

package/dist/cssbaseline/cssbaseline.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { CssBaselineProps } from '@material-ui/core/CssBaseline';
+import { ScopedCssBaselineProps } from '@material-ui/core/ScopedCssBaseline';
+export declare const McCssBaseline: React.FC<CssBaselineProps>;
+export declare const McScopedCssBaseline: React.FC<ScopedCssBaselineProps>;

package/dist/cssbaseline/cssbaseline.js

@@ -0,0 +1,41 @@
+"use strict";
+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 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McScopedCssBaseline = exports.McCssBaseline = void 0;
+var react_1 = __importDefault(require("react"));
+var CssBaseline_1 = __importDefault(require("@material-ui/core/CssBaseline"));
+var ScopedCssBaseline_1 = __importDefault(require("@material-ui/core/ScopedCssBaseline"));
+var McCssBaseline = function (props) {
+    var children = props.children, rest = __rest(props, ["children"]);
+    return react_1.default.createElement(CssBaseline_1.default, __assign({}, rest), children);
+};
+exports.McCssBaseline = McCssBaseline;
+var McScopedCssBaseline = function (props) {
+    var children = props.children, rest = __rest(props, ["children"]);
+    return react_1.default.createElement(ScopedCssBaseline_1.default, __assign({}, rest), children);
+};
+exports.McScopedCssBaseline = McScopedCssBaseline;

package/dist/cssbaseline/index.d.ts

@@ -0,0 +1 @@
+export { McCssBaseline as CssBaseline, McScopedCssBaseline as ScopedCssBaseline, } from './cssbaseline';

package/dist/cssbaseline/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopedCssBaseline = exports.CssBaseline = void 0;
+var cssbaseline_1 = require("./cssbaseline");
+Object.defineProperty(exports, "CssBaseline", { enumerable: true, get: function () { return cssbaseline_1.McCssBaseline; } });
+Object.defineProperty(exports, "ScopedCssBaseline", { enumerable: true, get: function () { return cssbaseline_1.McScopedCssBaseline; } });

package/dist/date-picker/date-picker.css

@@ -0,0 +1,9 @@
+body[dir='rtl'] .drpContainer .MuiInputLabel-formControl {
+  right: 0px;
+  left: unset;
+}
+
+body[dir='rtl'] .drpContainer .MuiInputBase-input {
+  direction: ltr;
+  text-align: end;
+}

package/dist/date-picker/date-picker.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { KeyboardDatePickerProps } from '@material-ui/pickers';
+import { SupportedLocales } from '../models/enums';
+import '@map-colonies/react-core/dist/button/styles';
+import './date-picker.css';
+interface DatePickerProps extends KeyboardDatePickerProps {
+    local?: {
+        placeHolderText?: string;
+        calendarLocale?: SupportedLocales;
+    };
+    showTime?: boolean;
+}
+export declare const DateTimePicker: React.FC<DatePickerProps>;
+export {};