@fleetbase/ember-core 0.0.1

package/addon/utils/group-api-events.js

@@ -0,0 +1,20 @@
+import { isArray } from '@ember/array';
+
+export default function groupApiEvents(webhookEvents = []) {
+    const groups = {};
+
+    if (isArray(webhookEvents)) {
+        for (let i = 0; i < webhookEvents.length; i++) {
+            const event = webhookEvents[i];
+            const eventResource = event.split('.')[0];
+            if (!groups[eventResource]) {
+                groups[eventResource] = [];
+            }
+            if (event.includes(eventResource)) {
+                groups[eventResource].push(event);
+            }
+        }
+    }
+
+    return groups;
+}

package/addon/utils/group-by.js

@@ -0,0 +1,26 @@
+import { get } from '@ember/object';
+
+export default function groupBy(arr, key) {
+    let grouped = {};
+    let _key;
+
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr.objectAt(i);
+
+        if (typeof key === 'string') {
+            _key = get(item, key);
+        }
+
+        if (typeof key === 'function') {
+            _key = key(item, i);
+        }
+
+        if (!grouped[_key]) {
+            grouped[_key] = [];
+        }
+
+        grouped[_key].pushObject(item);
+    }
+
+    return grouped;
+}

package/addon/utils/has-extension.js

@@ -0,0 +1,11 @@
+export default function hasExtension(pkg) {
+    let has = true;
+
+    try {
+        require(pkg);
+    } catch {
+        has = false;
+    }
+
+    return has;
+}

package/addon/utils/has-json-structure.js

@@ -0,0 +1,10 @@
+export default function hasJsonStructure(str) {
+    if (typeof str !== 'string') return false;
+    try {
+        const result = JSON.parse(str);
+        const type = Object.prototype.toString.call(result);
+        return type === '[object Object]' || type === '[object Array]';
+    } catch (err) {
+        return false;
+    }
+}

package/addon/utils/hason-structure.js

@@ -0,0 +1,3 @@
+export default function hasonStructure() {
+    return true;
+}

package/addon/utils/haversine.js

@@ -0,0 +1,59 @@
+var haversine = (function () {
+    var RADII = {
+        km: 6371,
+        mile: 3960,
+        meter: 6371000,
+        nmi: 3440,
+    };
+
+    // convert to radians
+    var toRad = function (num) {
+        return (num * Math.PI) / 180;
+    };
+
+    // convert coordinates to standard format based on the passed format option
+    var convertCoordinates = function (format, coordinates) {
+        switch (format) {
+            case '[lat,lon]':
+                return { latitude: coordinates[0], longitude: coordinates[1] };
+            case '[lon,lat]':
+                return { latitude: coordinates[1], longitude: coordinates[0] };
+            case '{lon,lat}':
+                return { latitude: coordinates.lat, longitude: coordinates.lon };
+            case '{lat,lng}':
+                return { latitude: coordinates.lat, longitude: coordinates.lng };
+            case 'geojson':
+                return {
+                    latitude: coordinates.geometry.coordinates[1],
+                    longitude: coordinates.geometry.coordinates[0],
+                };
+            default:
+                return coordinates;
+        }
+    };
+
+    return function haversine(startCoordinates, endCoordinates, options) {
+        options = options || {};
+
+        var R = options.unit in RADII ? RADII[options.unit] : RADII.km;
+
+        var start = convertCoordinates(options.format, startCoordinates);
+        var end = convertCoordinates(options.format, endCoordinates);
+
+        var dLat = toRad(end.latitude - start.latitude);
+        var dLon = toRad(end.longitude - start.longitude);
+        var lat1 = toRad(start.latitude);
+        var lat2 = toRad(end.latitude);
+
+        var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+        var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        if (options.threshold) {
+            return options.threshold > R * c;
+        }
+
+        return R * c;
+    };
+})();
+
+export default haversine;

package/addon/utils/humanize.js

@@ -0,0 +1,16 @@
+import { humanize as humanizeString } from 'ember-cli-string-helpers/helpers/humanize';
+
+export default function humanize(string) {
+    const uppercase = ['api', 'vat', 'id', 'uuid', 'sku', 'ean', 'upc', 'erp', 'tms', 'wms', 'ltl', 'ftl', 'lcl', 'fcl', 'rfid', 'jot', 'roi', 'eta', 'pod', 'asn', 'oem', 'ddp', 'fob'];
+
+    return humanizeString([string])
+        .split(' ')
+        .map((word) => {
+            if (uppercase.includes(word.toLowerCase())) {
+                return word.toUpperCase();
+            }
+
+            return word;
+        })
+        .join(' ');
+}

package/addon/utils/is-electron.js

@@ -0,0 +1,18 @@
+export default function isElectron() {
+    // Renderer process
+    if (typeof window !== 'undefined' && typeof window.process === 'object' && window.process.type === 'renderer') {
+        return true;
+    }
+
+    // Main process
+    if (typeof process !== 'undefined' && typeof process.versions === 'object' && !!process.versions.electron) {
+        return true;
+    }
+
+    // Detect the user agent when the `nodeIntegration` option is set to true
+    if (typeof navigator === 'object' && typeof navigator.userAgent === 'string' && navigator.userAgent.indexOf('Electron') >= 0) {
+        return true;
+    }
+
+    return false;
+}

package/addon/utils/is-email.js

@@ -0,0 +1,5 @@
+export default function isEmail(email) {
+    const pattern = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+
+    return pattern.test(email);
+}

package/addon/utils/is-function.js

@@ -0,0 +1,3 @@
+export default function isFunction() {
+    return true;
+}

package/addon/utils/is-image-file.js

@@ -0,0 +1,3 @@
+export default function isImageFile(type) {
+    return /image|jpg|jpeg|png|gif|webp/i.test(type);
+}

package/addon/utils/is-iterable.js

@@ -0,0 +1,7 @@
+export default function isIterable(obj) {
+    if (obj == null) {
+        return false;
+    }
+
+    return typeof obj[Symbol.iterator] === 'function';
+}

package/addon/utils/is-json.js

@@ -0,0 +1,9 @@
+export default function isJson(str) {
+    if (typeof str !== 'string') return false;
+    try {
+        JSON.parse(str);
+    } catch (e) {
+        return false;
+    }
+    return true;
+}

package/addon/utils/is-latitude.js

@@ -0,0 +1,3 @@
+export default function isLatitude(coordinate) {
+    return isFinite(coordinate) && Math.abs(coordinate) <= 90;
+}

package/addon/utils/is-letter.js

@@ -0,0 +1,3 @@
+export default function isLetter(l) {
+    return l.length === 1 && l.match(/[a-z]/i);
+}

package/addon/utils/is-longitude.js

@@ -0,0 +1,3 @@
+export default function isLongitude(coordinate) {
+    return isFinite(coordinate) && Math.abs(coordinate) <= 180;
+}

package/addon/utils/is-model.js

@@ -0,0 +1,6 @@
+import Model from '@ember-data/model';
+import ObjectProxy from '@ember/object/proxy';
+
+export default function isModel(mixed) {
+    return mixed instanceof Model || mixed instanceof ObjectProxy;
+}

package/addon/utils/is-not-empty.js

@@ -0,0 +1,5 @@
+import { isEmpty } from '@ember/utils';
+
+export default function isNotEmpty(...params) {
+    return !isEmpty(...params);
+}

package/addon/utils/is-not-model.js

@@ -0,0 +1,5 @@
+import isModel from './is-model';
+
+export default function isNotModel(model) {
+    return !isModel(model);
+}

package/addon/utils/is-numeric.js

@@ -0,0 +1,3 @@
+export default function isNumeric(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+}

package/addon/utils/is-object.js

@@ -0,0 +1,3 @@
+export default function isObject(obj) {
+    return typeof obj === 'object';
+}

package/addon/utils/is-proxy.js

@@ -0,0 +1,5 @@
+import ObjectProxy from '@ember/object/proxy';
+
+export default function isProxy(subject) {
+    return subject instanceof ObjectProxy;
+}

package/addon/utils/is-relation-missing.js

@@ -0,0 +1,21 @@
+import isset from './isset';
+import isModel from './is-model';
+import { underscore } from '@ember/string';
+
+export default function isRelationMissing(model, relation, options = {}) {
+    if (!isModel(model)) {
+        return false;
+    }
+
+    relation = underscore(relation);
+
+    const isMissingRelation = isset(model, `${relation}_uuid`) && !isset(model, ``);
+    const isNotMissingPolymorphicType = isset(model, `${relation}_type`);
+
+    if (isset(options, 'polymorphic') && options.polymorphic === true) {
+        // no relation is set, so false
+        return isNotMissingPolymorphicType && isset(model, `${relation}_uuid`);
+    }
+
+    return isMissingRelation;
+}

package/addon/utils/is-valid-coordinates.js

@@ -0,0 +1,38 @@
+import { isArray } from '@ember/array';
+import isLatitude from './is-latitude';
+import isLongitude from './is-longitude';
+import isObject from './is-object';
+
+/**
+ * Validates coordinates
+ *
+ * ```
+ * isValidCoordinates([0, 0]);
+ * isValidCoordinates({lat: 0, lng: 0});
+ * isValidCoordinates({latitude: 0, longitude: 0});
+ * isValidCoordinates(0, 0);
+ * ```
+ *
+ * @param {Array|Object|Integer} latitude
+ * @param {Array|Object|Integer} longitude
+ */
+export default function isValidCoordinates(latitude, longitude = null) {
+    let testLatitude, testLongitude;
+
+    if (isArray(latitude) && longitude === null) {
+        testLatitude = latitude[0];
+        testLongitude = latitude[1];
+    }
+
+    if (!isArray(latitude) && isObject(latitude) && longitude === null) {
+        testLatitude = latitude.lat || latitude.latitude;
+        testLongitude = latitude.lng || latitude.longitude;
+    }
+
+    if (longitude !== null) {
+        testLatitude = latitude;
+        testLongitude = longitude;
+    }
+
+    return isLatitude(testLatitude) && isLongitude(testLongitude);
+}

package/addon/utils/is-video-file.js

@@ -0,0 +1,3 @@
+export default function isVideoFile(type) {
+    return /video|mp4|mov|wmv|avi|flv/i.test(type);
+}

package/addon/utils/is-waypoint-record.js

@@ -0,0 +1,5 @@
+import WaypointModel from '../models/waypoint';
+
+export default function isWaypointRecord(record) {
+    return record instanceof WaypointModel;
+}

package/addon/utils/ison.js

@@ -0,0 +1,3 @@
+export default function ison() {
+    return true;
+}

package/addon/utils/isset.js

@@ -0,0 +1,10 @@
+import { isBlank } from '@ember/utils';
+import { get } from '@ember/object';
+
+export default function isset(target, key = null) {
+    if (key === null) {
+        return !isBlank(target);
+    }
+
+    return !isBlank(get(target, key));
+}

package/addon/utils/last.js

@@ -0,0 +1,23 @@
+import { isArray } from '@ember/array';
+
+const isNumber = (value) => typeof value === 'number' && isFinite(value);
+
+export default function last(arr, n = 1) {
+    if (!isArray(arr) || arr.length === 0) {
+        return null;
+    }
+
+    n = isNumber(n) ? +n : 1;
+
+    if (n === 1) {
+        return arr[arr.length - 1];
+    }
+
+    let res = new Array(n);
+
+    while (n--) {
+        res[n] = arr[--len];
+    }
+
+    return res;
+}

package/addon/utils/lazy-load-script.js

@@ -0,0 +1,25 @@
+import { guidFor } from '@ember/object/internals';
+
+export default function lazyLoadScript(path) {
+    return new Promise(function (resolve, reject) {
+        const id = guidFor(path);
+
+        if (document.getElementById(id)) {
+            return resolve();
+        }
+
+        const element = document.createElement('script');
+        element.id = id;
+        element.src = path;
+
+        element.addEventListener('load', function () {
+            resolve();
+        });
+
+        element.addEventListener('error', function () {
+            reject(`Failed to load script (${path})`);
+        });
+
+        document.getElementsByTagName('head')[0].appendChild(element);
+    });
+}

package/addon/utils/leaflet-icon.js

@@ -0,0 +1,13 @@
+/* global L */
+
+/**
+ * Represents an icon to provide when creating a marker.
+ * More information about its possible options [here](https://leafletjs.com/reference-1.7.1.html#icon-option).
+ *
+ * @function leafletIcon
+ * @param {Object} options the Icon options object
+ * @return {Icon}
+ */
+export default function leafletIcon(options = {}) {
+    return L.icon(options);
+}

package/addon/utils/leaflet-points-from-coordinates.js

@@ -0,0 +1,3 @@
+export default function leafletPointsFromCoordinates() {
+    return true;
+}

package/addon/utils/load-engines.js

@@ -0,0 +1,37 @@
+import { dasherize } from '@ember/string';
+import hostServices from '../exports/host-services';
+
+export default async function loadEngines(appInstance, withServices = []) {
+    return new Promise((resolve, reject) => {
+        return fetch('extensions.json')
+            .then((resp) => resp.json())
+            .then((extensions) => {
+                const engines = {};
+                const externalRoutes = {
+                    console: 'console.home',
+                    extensions: 'console.extensions',
+                };
+
+                for (let i = 0; i < extensions.length; i++) {
+                    const extension = extensions[i];
+                    const path = dasherize(extension.extension);
+
+                    externalRoutes[path] = `console.${path}`;
+                }
+
+                for (let i = 0; i < extensions.length; i++) {
+                    const extension = extensions[i];
+
+                    engines[extension.name] = {
+                        dependencies: {
+                            services: [...hostServices, ...withServices],
+                            externalRoutes,
+                        },
+                    };
+                }
+
+                resolve(engines);
+            })
+            .catch(reject);
+    });
+}

package/addon/utils/load-extensions.js

@@ -0,0 +1,8 @@
+export default async function loadExtensions() {
+    return new Promise((resolve, reject) => {
+        return fetch('/extensions.json')
+            .then((resp) => resp.json())
+            .then(resolve)
+            .catch(reject);
+    });
+}

package/addon/utils/macros/group-by.js

@@ -0,0 +1,28 @@
+import { A } from '@ember/array';
+import { computed, get } from '@ember/object';
+import { isPresent } from '@ember/utils';
+
+export default function groupBy(collection, property) {
+    let dependentKey = collection + '.@each.' + property;
+
+    return computed(dependentKey, function () {
+        let groups = A();
+        let items = get(this, collection);
+
+        if (items) {
+            items.forEach(function (item) {
+                let value = get(item, property);
+                let group = groups.findBy('value', value);
+
+                if (isPresent(group)) {
+                    group.items.push(item);
+                } else {
+                    group = { property: property, value: value, items: [item] };
+                    groups.push(group);
+                }
+            });
+        }
+
+        return groups;
+    }).readOnly();
+}

package/addon/utils/make-dataset.js

@@ -0,0 +1,57 @@
+import groupBy from './group-by';
+import { _range } from './range';
+import { format, startOfMonth, endOfMonth, startOfDay, sub, addDays } from 'date-fns';
+
+function randomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min) + min);
+}
+
+function randomDateThisMonth() {
+    const now = new Date();
+    const startDate = startOfMonth(now);
+    const endDate = endOfMonth(now);
+    const diffInDays = (endDate - startDate) / (1000 * 60 * 60 * 24);
+    return addDays(startDate, randomInt(0, diffInDays));
+}
+
+function makeMockDataset(start, end, dateProperty = 'created_at') {
+    const data = _range(start, end).map(() => {
+        return {
+            created_at: randomDateThisMonth(),
+        };
+    });
+    const grouped = groupBy(data, (record) => {
+        return format(new Date(record[dateProperty]), 'MMMM, dd yyyy');
+    });
+    const dataset = [];
+
+    for (let day in grouped) {
+        dataset.pushObject({
+            t: new Date(`${day} 00:00:00`),
+            y: grouped[day].length,
+        });
+    }
+
+    return dataset.sortBy('t');
+}
+
+export { makeMockDataset, randomInt, randomDateThisMonth, _range as range };
+
+export default function makeDataset(recordArray, filter = Boolean, dateProperty = 'created_at') {
+    const filteredData = recordArray.filter(filter);
+    const grouped = groupBy(filteredData, (record) => {
+        return format(new Date(record[dateProperty]), 'MMMM, dd yyyy');
+    });
+    const dataset = [];
+
+    for (let day in grouped) {
+        dataset.pushObject({
+            t: new Date(`${day} 00:00:00`),
+            y: grouped[day].length,
+        });
+    }
+
+    return dataset.sortBy('t');
+}

package/addon/utils/map-engines.js

@@ -0,0 +1,30 @@
+import { dasherize } from '@ember/string';
+import hostServices from '../exports/host-services';
+
+export default function mapEngines(extensions, withServices = []) {
+    const engines = {};
+    const externalRoutes = {
+        console: 'console.home',
+        extensions: 'console.extensions',
+    };
+
+    for (let i = 0; i < extensions.length; i++) {
+        const extension = extensions[i];
+        const path = dasherize(extension.extension);
+
+        externalRoutes[path] = `console.${path}`;
+    }
+
+    for (let i = 0; i < extensions.length; i++) {
+        const extension = extensions[i];
+
+        engines[extension.name] = {
+            dependencies: {
+                services: [...hostServices, ...withServices],
+                externalRoutes,
+            },
+        };
+    }
+
+    return engines;
+}

package/addon/utils/mock-response.js

@@ -0,0 +1,15 @@
+export default function mockResponse() {
+    const response = [];
+    response.meta = {
+        current_page: 1,
+        from: 1,
+        last_page: 1,
+        per_page: 25,
+        to: 1,
+        total: 1,
+    };
+
+    return new Promise((resolve) => {
+        resolve(response);
+    });
+}

package/addon/utils/numbers-only.js

@@ -0,0 +1,11 @@
+export default function numbersOnly(string, keepDecimals = false) {
+    if (typeof string !== 'string') {
+        return string;
+    }
+
+    if (keepDecimals === true) {
+        return string.replace(/[^0-9.]+/g, '');
+    }
+
+    return string.replace(/\D+/g, '');
+}

package/addon/utils/past-tense.js

@@ -0,0 +1,40 @@
+export default function pastTense(verb) {
+    const exceptions = {
+        are: 'were',
+        eat: 'ate',
+        go: 'went',
+        have: 'had',
+        inherit: 'inherited',
+        is: 'was',
+        run: 'ran',
+        sit: 'sat',
+        visit: 'visited',
+    };
+
+    if (exceptions[verb]) {
+        return exceptions[verb];
+    }
+
+    if (/e$/i.test(verb)) {
+        return verb + 'd';
+    }
+
+    if (/[aeiou]c/i.test(verb)) {
+        return verb + 'ked';
+    }
+
+    // for american english only
+    if (/el$/i.test(verb)) {
+        return verb + 'ed';
+    }
+
+    if (/[aeio][aeiou][dlmnprst]$/.test(verb)) {
+        return verb + 'ed';
+    }
+
+    if (/[aeiou][bdglmnprst]$/i.test(verb)) {
+        return verb.replace(/(.+[aeiou])([bdglmnprst])/, '$1$2$2ed');
+    }
+
+    return verb + 'ed';
+}