@sedoo/unidoo 0.1.71 → 0.1.73

package/src/components/UnidooTrajectoryMap.vue

@@ -4,86 +4,92 @@
 </template>
 
 <script>
-  import View from 'ol/View'
-  import Map from 'ol/Map'
-  import TileLayer from 'ol/layer/Tile'
-  import OSM from 'ol/source/OSM'
-    import GeoJSON from 'ol/format/GeoJSON';
-      import VectorLayer from 'ol/layer/Vector'
-  import VectorSource from 'ol/source/Vector'
-  import { Stroke, Style } from 'ol/style';
-  // importing the OpenLayers stylesheet is required for having
-  // good looking buttons!
-  import 'ol/ol.css'
+import View from "ol/View";
+import Map from "ol/Map";
+import TileLayer from "ol/layer/Tile";
+import OSM from "ol/source/OSM";
+import GeoJSON from "ol/format/GeoJSON";
+import VectorLayer from "ol/layer/Vector";
+import VectorSource from "ol/source/Vector";
+import { Stroke, Style } from "ol/style";
+// importing the OpenLayers stylesheet is required for having
+// good looking buttons!
+import "ol/ol.css";
 
-  export default {
-    name: 'MapContainer',
-    components: {},
-    props: {
+export default {
+  name: "MapContainer",
+  components: {},
+  props: {
     color: {
       type: String,
-      default: 'red',
+      default: "red"
     },
     json: {
       type: String,
-      default: '',
-    },
-    },
-    mounted() {
-      this.axios.get(this.json)
-      .then(res => {
-            const geoJsonObject = res.data
-             geoJsonObject.crs = {
-                type: 'name',
-                properties: {
-                name: 'EPSG:3857',
-                },
-            } 
-            const styles = {
-                LineString: new Style({
-                    stroke: new Stroke({
-                    color: this.color,
-                    width: 2,
-                    }),
-                }),
-            }
-            const styleFunction = function (feature) {
-            return styles[feature.getGeometry().getType()];
-            };
-            const vectorSource = new VectorSource({
-                features: new GeoJSON().readFeatures(geoJsonObject, {
-            dataProjection: 'EPSG:4326',
-          featureProjection: 'EPSG:3857'
-        })
+      default: ""
+    }
+  },
+  mounted() {
+    this.axios
+      .get(this.json)
+      .then((res) => {
+        const geoJsonObject = res.data;
+        geoJsonObject.crs = {
+          type: "name",
+          properties: {
+            name: "EPSG:3857"
+          }
+        };
+        const styles = {
+          LineString: new Style({
+            stroke: new Stroke({
+              color: this.color,
+              width: 2
             })
+          })
+        };
+        const styleFunction = function (feature) {
+          return styles[feature.getGeometry().getType()];
+        };
+        const vectorSource = new VectorSource({
+          features: new GeoJSON().readFeatures(geoJsonObject, {
+            dataProjection: "EPSG:4326",
+            featureProjection: "EPSG:3857"
+          })
+        });
 
-            const vectorLayer = new VectorLayer({
-                source: vectorSource,
-                style: styleFunction,
-                });
+        const vectorLayer = new VectorLayer({
+          source: vectorSource,
+          style: styleFunction
+        });
 
-            // this is where we create the OpenLayers map
-      // eslint-disable-next-line no-new
-     new Map({
-        // the map will be created using the 'map-root' ref
-        target: this.$refs['map-root'],
-        layers: [
-          // adding a background tiled layer
-          new TileLayer({
-            source: new OSM() // tiles are served by OpenStreetMap
-          }),
-          vectorLayer
-        ],
+        // this is where we create the OpenLayers map
+        // eslint-disable-next-line no-new
+        new Map({
+          // the map will be created using the 'map-root' ref
+          target: this.$refs["map-root"],
+          layers: [
+            // adding a background tiled layer
+            new TileLayer({
+              source: new OSM() // tiles are served by OpenStreetMap
+            }),
+            vectorLayer
+          ],
 
-        // the map view will initially show the whole world
-        view: new View({
-          zoom: 0,
-          center: [0, 0],
-          constrainResolution: true,
-          projection: 'EPSG:3857'
-        }),
-      }).getView().fit(vectorSource.getExtent());
+          // the map view will initially show the whole world
+          view: new View({
+            zoom: 0,
+            center: [0, 0],
+            constrainResolution: true,
+            projection: "EPSG:3857"
+          })
         })
-    },
+          .getView()
+          .fit(vectorSource.getExtent());
+      })
+      .catch((e) => {
+        console.error(e);
+      });
   }
+};
 </script>

package/src/components/unidoo-heatmap/Heatmap.js

@@ -1,74 +1,80 @@
-
 export default class CalendarHeatmap {
-  constructor (year, values, max) {
-    this.year = this._parseDate(year)
-    if (typeof max === 'number' && max >= 0) {
-      this.max = max
+  constructor(year, values, max) {
+    if (typeof window === "undefined") return;
+    this.year = this._parseDate(year);
+    if (typeof max === "number" && max >= 0) {
+      this.max = max;
     } else {
-      this.max = Math.ceil((Math.max(...values.map(day => day.count)) / 5) * 4)
+      this.max = Math.ceil(
+        (Math.max(...values.map((day) => day.count)) / 5) * 4
+      );
     }
-    this.values = values.map(v => { return { date: this._valuesDateFormat(v.date), count: v.count } })
-    this.times = this._getTimes(this.year.getFullYear())
-    this.times.sort()
+    this.values = values.map((v) => {
+      return { date: this._valuesDateFormat(v.date), count: v.count };
+    });
+    this.times = this._getTimes(this.year.getFullYear());
+    this.times.sort();
   }
 
-  get activities () {
+  get activities() {
     return this.values.reduce((newValues, day) => {
       newValues[this._keyDayParser(day.date)] = {
         count: day.count,
         colorIndex: this.getColorIndex(day.count)
-      }
-      return newValues
-    }, {})
+      };
+      return newValues;
+    }, {});
   }
 
-  get monthCalendar () {
-    const year = this.year.getFullYear()
-    const date = new Date(year, 0, 1).toUnidooUTC()
-    let i = 0
-    return Array.from({ length: 12 },
-      () => Array.from({ length: this.daysInMonth(year, i++) },
-        () => {
-          const dDate = new Date(date.getFullYear(), date.getMonth(), date.getDate()).toUnidooUTC()
-          const dayValues = this.activities[this._keyDayParser(dDate)]
-          date.setDate(date.getDate() + 1)
-          return {
-            date: dDate,
-            count: dayValues ? dayValues.count : null,
-            colorIndex: dayValues ? dayValues.colorIndex : 0
-          }
-        }
-      )
-    )
+  get monthCalendar() {
+    const year = this.year.getFullYear();
+    const date = new Date(year, 0, 1).toUnidooUTC();
+    let i = 0;
+    return Array.from({ length: 12 }, () =>
+      Array.from({ length: this.daysInMonth(year, i++) }, () => {
+        const dDate = new Date(
+          date.getFullYear(),
+          date.getMonth(),
+          date.getDate()
+        ).toUnidooUTC();
+        const dayValues = this.activities[this._keyDayParser(dDate)];
+        date.setDate(date.getDate() + 1);
+        return {
+          date: dDate,
+          count: dayValues ? dayValues.count : null,
+          colorIndex: dayValues ? dayValues.colorIndex : 0
+        };
+      })
+    );
   }
 
-  daysInMonth (year, month) {
-    return new Date(year, month + 1, 0).toUnidooUTC().getDate()
+  daysInMonth(year, month) {
+    return new Date(year, month + 1, 0).toUnidooUTC().getDate();
   }
 
   daysInYear(year) {
-    const start = new Date(year, 0, 0).toUnidooUTC()
-    const end = new Date(year, 11, 31).toUnidooUTC()
-    const diff = end - start
-    return Math.floor(diff / (1000 * 60 * 60 * 24))
+    const start = new Date(year, 0, 0).toUnidooUTC();
+    const end = new Date(year, 11, 31).toUnidooUTC();
+    const diff = end - start;
+    return Math.floor(diff / (1000 * 60 * 60 * 24));
   }
 
-  getColorIndex (value) {
+  getColorIndex(value) {
     if (value == null || value === undefined) {
-      return 0
+      return 0;
     } else if (value >= this.max) {
-      return 5
+      return 5;
     } else if (value <= 0) {
-      return 1
+      return 1;
     } else {
-      return (Math.ceil(((value * 100) / this.max) * (0.03))) + 1
+      return Math.ceil(((value * 100) / this.max) * 0.03) + 1;
     }
   }
 
   getDayFromDate(entry) {
-    if (entry) { 
+    if (entry) {
       const sdate = this._valuesDateFormat(entry);
-      const day = this.values.filter(d => d.date === sdate)[0];
+      const day = this.values.filter((d) => d.date === sdate)[0];
       if (day) {
         return {
           date: new Date(day.date).toUnidooUTC(),
@@ -76,108 +82,119 @@ export default class CalendarHeatmap {
           colorIndex: this.getColorIndex(day.count)
         };
       } else {
-        return { date: new Date(entry).toUnidooUTC(), count: NaN, colorIndex: 0 };
+        return {
+          date: new Date(entry).toUnidooUTC(),
+          count: NaN,
+          colorIndex: 0
+        };
       }
     }
   }
 
   getNextAvailableDate(date, countGreaterThanZero) {
     if (date) {
-      date.setHours(0, 0, 0)
+      date.setHours(0, 0, 0);
       if (this.times && this.times.length) {
-        let index = this.times.indexOf(this._encodeDate(date, null))
-        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 1))
-        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 0))
+        let index = this.times.indexOf(this._encodeDate(date, null));
+        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 1));
+        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 0));
         if (index >= 0) {
-          const maxIndex = this.times.length - 1
-          let n = index + 1
+          const maxIndex = this.times.length - 1;
+          let n = index + 1;
           if (countGreaterThanZero) {
             while (n <= maxIndex) {
-              const curr = this.times[n]
-              if (curr.endsWith('i')) return this._decodeDate(curr)
-              n++
+              const curr = this.times[n];
+              if (curr.endsWith("i")) return this._decodeDate(curr);
+              n++;
             }
           } else {
             while (n <= maxIndex) {
-              const curr = this.times[n]
-              if (!curr.endsWith('n')) return this._decodeDate(curr)
-              n++
+              const curr = this.times[n];
+              if (!curr.endsWith("n")) return this._decodeDate(curr);
+              n++;
             }
           }
-        } 
+        }
       }
     }
-    return null
+    return null;
   }
 
   getPreviousAvailableDate(date, countGreaterThanZero) {
-    if (date) { 
-      date.setHours(0, 0, 0)
+    if (date) {
+      date.setHours(0, 0, 0);
       if (this.times && this.times.length) {
-        let index = this.times.indexOf(this._encodeDate(date, null))
-        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 1))
-        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 0))
+        let index = this.times.indexOf(this._encodeDate(date, null));
+        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 1));
+        if (index < 0) index = this.times.indexOf(this._encodeDate(date, 0));
         if (index >= 0) {
-          let n = index - 1
+          let n = index - 1;
           if (countGreaterThanZero) {
             while (n >= 0) {
-              const curr = this.times[n]
-              if (curr.endsWith('i')) return this._decodeDate(curr)
-              n--
+              const curr = this.times[n];
+              if (curr.endsWith("i")) return this._decodeDate(curr);
+              n--;
             }
           } else {
             while (n >= 0) {
-              const curr = this.times[n]
-              if (!curr.endsWith('n')) return this._decodeDate(curr)
-              n--
+              const curr = this.times[n];
+              if (!curr.endsWith("n")) return this._decodeDate(curr);
+              n--;
             }
           }
         }
       }
     }
-    return null
+    return null;
   }
 
-  _getTimes (year) {
-    const date = new Date(year, 0, 1).toUnidooUTC()
-    return Array.from({ length: this.daysInYear(year) }, 
-      () => {
-        const dDate = new Date(date.getFullYear(), date.getMonth(), date.getDate()).toUnidooUTC()
-        dDate.setHours(0, 0, 0)
-        const dayValues = this.activities[this._keyDayParser(dDate)]
-        date.setDate(date.getDate() + 1)
-        return this._encodeDate(dDate, (dayValues) ? dayValues.count : null)
-      }
-    )
+  _getTimes(year) {
+    const date = new Date(year, 0, 1).toUnidooUTC();
+    return Array.from({ length: this.daysInYear(year) }, () => {
+      const dDate = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate()
+      ).toUnidooUTC();
+      dDate.setHours(0, 0, 0);
+      const dayValues = this.activities[this._keyDayParser(dDate)];
+      date.setDate(date.getDate() + 1);
+      return this._encodeDate(dDate, dayValues ? dayValues.count : null);
+    });
   }
-  
-  _valuesDateFormat (d) {
-    if (!d) return ''
-    const date = this._parseDate(d)
-    return `${date.getFullYear()}-${this._paddNumber(date.getMonth() + 1)}-${this._paddNumber(date.getDate())}`
+
+  _valuesDateFormat(d) {
+    if (!d) return "";
+    const date = this._parseDate(d);
+    return `${date.getFullYear()}-${this._paddNumber(
+      date.getMonth() + 1
+    )}-${this._paddNumber(date.getDate())}`;
   }
 
-  _paddNumber (n) {
-    return ('' + n).padStart(2, '0')
+  _paddNumber(n) {
+    return ("" + n).padStart(2, "0");
   }
 
-  _encodeDate (d, count) {
-    const date = this._parseDate(d)
-    return this._valuesDateFormat(date) + ((Number.isFinite(count)) ? ((count > 0) ? 'i' : 'o') : 'n')
+  _encodeDate(d, count) {
+    const date = this._parseDate(d);
+    return (
+      this._valuesDateFormat(date) +
+      (Number.isFinite(count) ? (count > 0 ? "i" : "o") : "n")
+    );
   }
 
-  _decodeDate (d) {
-    if (!d) return null
-    const sdate = d.slice(0, -1)
-    return new Date(sdate).toUnidooUTC()
+  _decodeDate(d) {
+    if (!d) return null;
+    const sdate = d.slice(0, -1);
+    return new Date(sdate).toUnidooUTC();
   }
 
-  _parseDate (entry) {
-    return (entry instanceof Date) ? entry : (new Date(entry).toUnidooUTC())
+  _parseDate(entry) {
+    return entry instanceof Date ? entry : new Date(entry).toUnidooUTC();
   }
 
-  _keyDayParser (date) {
-    const day = this._parseDate(date)
-    return `${day.getFullYear()}-${day.getMonth()}-${day.getDate()}`
+  _keyDayParser(date) {
+    const day = this._parseDate(date);
+    return `${day.getFullYear()}-${day.getMonth()}-${day.getDate()}`;
   }
-}
+}