@selkirk-systems/selkirk-utils 1.0.2 → 1.0.5

package/lib/utils/CacheUtils.js

@@ -0,0 +1,25 @@
+export const withPromiseCache = ( fn, cacheFn = () => { } ) => {
+
+    const cacheMap = {};
+
+    return ( ...args ) => {
+
+        const cache = cacheFn( ...args );
+        const cacheId = args.join( ":" );
+
+
+        if ( cache ) {
+            return cache;
+        }
+
+        if ( cacheMap.hasOwnProperty( cacheId ) ) return cacheMap[cacheId];
+
+        cacheMap[cacheId] = fn( ...args ).finally( () => {
+
+            delete cacheMap[cacheId];
+
+        } );
+
+        return cacheMap[cacheId];
+    }
+}

package/lib/utils/DateUtils.js

@@ -0,0 +1,86 @@
+import { format } from "date-fns"
+
+export const formatDate = ( timestamp, formatStr, COMMON_DATE_FORMAT ) => {
+
+    if ( timestamp === null || timestamp === undefined ) return '';
+
+    return format( timestamp, formatStr || COMMON_DATE_FORMAT )
+
+
+}
+
+export const formatYearlessColumnDate = ( value, offsetDays ) => {
+    if(offsetDays != undefined){
+        value += offsetDays * 1000 * 60 * 60 * 24;
+    }
+
+    return format( new Date( value ), "MMM dd" );
+
+}
+
+export const formatColumnDate = ( data, value ) => {
+
+    return format( new Date( value ), "MMM dd, yyyy" );
+
+}
+
+
+export const formateDateAndTime = ( timestamp ) => {
+
+
+    return format( timestamp, "MMM dd, yyyy@HH:mm" );
+
+
+}
+
+export const startOfCurrentYear = () => {
+
+    return new Date( new Date().getFullYear(), 0, 1 ).getTime();
+
+}
+
+export const lastYearTimestamp = () => {
+
+    var d = new Date( new Date().getFullYear() - 1, 0, 1 );
+    d.setHours( 0, 0, 0, 0 );
+    return d.getTime();
+
+}
+
+export const DateToTimestamp = ( date ) => date.getTime();
+export const TimestampToDate = ( timestamp ) => new Date( timestamp );
+
+export const getTodaysDate = () => {
+    let localeOptions = { month: 'short', day: 'numeric', year: 'numeric' };
+    return new Date().toLocaleDateString( 'en-US', localeOptions );
+}
+
+export const getYesterdaysDate = () => {
+    let localeOptions = { month: 'short', day: 'numeric', year: 'numeric' };
+    return new Date( new Date().setDate( new Date().getDate() - 1 ) ).toLocaleDateString( 'en-US', localeOptions );
+}
+
+export const convertTimestampToDateString = ( date ) => {
+    let localeOptions = { month: 'short', day: 'numeric', year: 'numeric' };
+    return new Date( date ).toLocaleDateString( 'en-US', localeOptions );
+}
+
+export const convertTimestampToTimeString = ( date ) => {
+    let localeOptions = { month: 'numeric', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit' };
+    return new Date( date ).toLocaleTimeString( 'en-US', localeOptions );
+}
+
+export const getCurrentDateString = ( creationTimestamp ) => {
+    const today = getTodaysDate();
+    const yesterday = getYesterdaysDate();
+    const commentDate = convertTimestampToDateString( creationTimestamp );
+
+
+    if ( commentDate === today ) {
+        return 'Today';
+    } else if ( commentDate === yesterday ) {
+        return 'Yesterday';
+    } else {
+        return commentDate;
+    }
+}

package/lib/utils/EntityUtils.js

@@ -0,0 +1,48 @@
+
+
+export const getEntityLinkId = ( obj, propName ) => {
+
+    if ( !obj._links ) return null;
+
+    const href = obj._links[propName]?.href || "";
+
+    return getIdFromHref( href );
+}
+
+
+export const getEntityLinkTitle = ( obj, propName ) => {
+
+    if ( !obj._links ) return null;
+
+    return obj._links[propName]?.title;
+
+}
+
+export const createLinkObj = ( obj ) => {
+    return {
+        href: obj?._links?.self?.href,
+        title: obj?.displayLabel
+    }
+}
+
+export const getIdFromHref = ( href ) => {
+
+    const hrefArray = href.split( "/" );
+
+    return hrefArray.length ? hrefArray[hrefArray.length - 1] : null;
+}
+
+
+export const getEntityTypeByObj = (obj)=>{
+    const reg = /.com(:\d+)?\/(.+?)\//g;
+
+    if(!obj?._links?.self?.href) return null;
+
+    const match = reg.exec(obj._links.self.href);
+
+    if(!match.length || match.length<2){
+        return null
+    }
+
+    return match[2];
+}

package/lib/utils/EnvUtils.js

@@ -0,0 +1,88 @@
+import { createPortal } from "react-dom";
+
+export const getEnvironmentVariable = ( name ) => {
+
+
+    return process.env[`REACT_APP_${name}`];
+
+
+}
+
+export const createUrlParams = ( params, existingParams ) => {
+
+
+    const searchParams = existingParams ? existingParams : new URLSearchParams();
+
+    for ( var prop in params ) {
+        if ( !params.hasOwnProperty( prop ) || params[prop] === undefined || params[prop] === null ) continue;
+
+        if ( Array.isArray( params[prop] ) ) {
+
+            if ( prop === "sort" ) {
+                searchParams.delete( "sort" );
+            }
+
+            for ( let i = 0; i < params[prop].length; i++ ) {
+                const e = params[prop][i];
+                if ( searchParams.has( prop ) && prop !== "sort" ) {
+                    searchParams.set( prop, e );
+                }
+                else {
+                    searchParams.append( prop, e );
+                }
+            }
+            continue;
+        }
+
+        if ( searchParams.has( prop ) ) {
+            searchParams.set( prop, params[prop] );
+        }
+        else {
+            searchParams.append( prop, params[prop] );
+        }
+    }
+
+
+    return searchParams;
+
+
+}
+
+//TODO: DRY these up
+export const createGISURL = ( basePath,path="",params )=>{
+    const baseUrl = `${window.location.origin}${window.baseURL}/gis/`;
+    const url = new URL( `${baseUrl}${basePath}${path !== "" ? "/" + path : path}` );
+
+    if ( !params ) return url;
+
+    url.search = createUrlParams( params );
+
+    return url;
+}
+
+export const createProxiedURL = ( basePath, path = "", params ) => {
+
+    const baseUrl = `${window.location.origin}${window.baseURL||''}/p/`;
+    const url = new URL( `${baseUrl}${basePath}${path !== "" ? "/" + path : path}` );
+
+    if ( !params ) return url;
+
+    url.search = createUrlParams( params );
+
+    return url;
+}
+
+
+export const createApiURL = ( basePath, path = "", qParams ) => {
+
+    const baseUrl = `${window.location.origin}${window.baseURL}/api`;
+    const url = new URL( `${baseUrl}${basePath}${path !== "" ? "/" + path : path}` );
+
+    if ( !qParams ) return url;
+
+    url.search = createUrlParams( qParams );
+
+    return url;
+
+
+}

package/lib/utils/FetchUtils.js

@@ -0,0 +1,68 @@
+import { dispatch } from "@selkirk-systems/state-management";
+
+export const serializeResponse = ( [response, isAbort] ) => {
+    //Is any status is outside 200 - 299 it is not ok
+    if ( response.status.code < 200 || response.status.code >= 300 || isAbort ) {
+        return [response, isAbort];
+    }
+    if ( Array.isArray( response.data ) ) {
+        return [response, isAbort];
+    }
+    if ( response.data._embedded ) {
+        response.data.items = response.data._embedded[[Object.keys( response.data._embedded )[0]]];
+        delete response.data._embedded;
+        return [response, isAbort];
+    } else {
+        response.data.items = [];
+    }
+    return [response, isAbort];
+}
+
+export const blockOnError = fn => ([err,data,results])=>{
+    if(err){
+        return;
+    }
+
+    fn([data,results]);
+}
+
+export const serializeAndRespondWith = (action,payload={}) => {
+    /**
+    * Callback function for a Fetch call then()
+    * @name serializeCallbackFn
+    * @method
+    * 
+    * @param {array}         array             - Response array return by the Fetch library
+    * @param {object}        array.response    - data returned from the Fetch call
+    * @param {boolean}       array.isAbort     - was the fetch call aborted for some reason.
+    * 
+    * @returns {array<object,boolean>}
+    */
+    return ([response, isAbort]) => {
+      //Is any status is outside 200 - 299 it is not ok
+      if (response.status.code < 200 || response.status.code >= 300 || isAbort) {
+        return [response, isAbort];
+      }
+      let data = {};
+      if (Array.isArray(response.data)) {
+        dispatch(action, {
+          items: response.data
+        });
+        return [response, isAbort];
+      } else {
+        data = {
+          ...response.data
+        };
+      }
+      if (data._embedded) {
+        data.items = data._embedded[[Object.keys(data._embedded)[0]]];
+        delete data._embedded;
+        dispatch(action, {...data,...payload});
+        return [response, isAbort];
+      } else {
+        data.items = [];
+      }
+      dispatch(action, {...data,...payload});
+      return [response, isAbort];
+    };
+  };

package/lib/utils/IncidentUtils.js

@@ -0,0 +1,26 @@
+const WILDFIRE_STATUS_PRIORITY = {
+    "OC":1,
+    "BH":2,
+    "UC":3,
+    "EX":4,
+    "TO":5
+}
+
+export function getHighestPriorityStatus(clusterDataArray){
+
+    let status = null;
+
+    clusterDataArray.reduce(
+        (acc, loc) =>{
+            if(  WILDFIRE_STATUS_PRIORITY[acc.status] < WILDFIRE_STATUS_PRIORITY[loc.status]){
+                status = acc.status
+                return acc;
+            }
+
+            status = loc.status;
+            return loc;
+        }
+      )
+
+      return status;
+}

package/lib/utils/LayerUtils.js

@@ -0,0 +1,7 @@
+export const isArcGisLayerDescendant = ( child, parent ) => {
+    return child.parentLayer?.id.toString() === parent.id.toString()
+}
+
+export const isMapProfileLayerDescendant = ( child, parent ) => {
+    return child.parentLayerId === parent.id
+}

package/lib/utils/ListUtils.js

@@ -0,0 +1,56 @@
+
+/**
+ * Return an array containing all descendants of the supplied parentId
+ * 
+ * @param {Object[]} arrayOfLayers Flat Array of objects with a parentId
+ * @param {Object} parent Top level parent
+ * @param {function} idFn function that returns true if it should be a descendant
+ * @returns {Object[]}
+ */
+export const getAllDescendants = ( arrayOfLayers, parent, idFn ) => {
+
+    let ret = [];
+
+    for ( let i = 0; i < arrayOfLayers.length; i++ ) {
+
+        const layer = arrayOfLayers[i];
+
+        if ( idFn( layer, parent ) ) {
+            ret.push( layer );
+            ret = ret.concat( getAllDescendants( arrayOfLayers, layer, idFn ) )
+        }
+
+
+    }
+
+    return ret;
+
+}
+
+
+export const getAllAncestors = ( arrayOfLayers, parent, idFn ) => {
+
+    let ret = [];
+
+    for ( let i = 0; i < arrayOfLayers.length; i++ ) {
+
+        const layer = arrayOfLayers[i];
+
+        if ( idFn( parent, layer ) ) {
+            ret.push( layer );
+            ret = ret.concat( getAllAncestors( arrayOfLayers, layer, idFn ) )
+        }
+
+
+    }
+
+    return ret;
+
+}
+
+
+export function isParentLayer( list, layer ) {
+
+    return list.find( item => item.parentLayerId === layer.id );
+
+}

package/lib/utils/MapUtils.js

@@ -0,0 +1,194 @@
+/* eslint-disable no-redeclare */
+import * as numeral from "numeral";
+import * as L from "leaflet";
+
+const long =
+    /^(\+|-)?(?:180(?:(?:\.0{1,6})?)|(?:[0-9]|[1-9][0-9]|1[0-7][0-9])(?:(?:\.[0-9]{1,6})?))$/;
+const lat =
+    /^(\+|-)?(?:90(?:(?:\.0{1,6})?)|(?:[0-9]|[1-8][0-9])(?:(?:\.[0-9]{1,6})?))$/;
+const latitude = (coordinate) => lat.test(coordinate);
+const longitude = (coordinate) => long.test(coordinate);
+const latLong = (lat, long) => latitude(lat) && longitude(long);
+
+const validationLatitudeLongitude = {
+    latitude,
+    longitude,
+    latLong,
+};
+
+export const boundContains = (bounds, arrayOfLayers) => {
+    return arrayOfLayers.filter((layer) => {
+        return bounds.contains(layer.getLatLng());
+    });
+};
+
+export const checkGeoFence = (point, polygon) => {
+    if (polygon[0] !== polygon[polygon.length - 1])
+        polygon[polygon.length] = polygon[0];
+    let j = 0;
+    let oddNodes = false;
+    let x = point[1];
+    let y = point[0];
+    let n = polygon.length;
+    for (let i = 0; i < n; i++) {
+        j++;
+        if (j === n) {
+            j = 0;
+        }
+        if (
+            (polygon[i][0] < y && polygon[j][0] >= y) ||
+            (polygon[j][0] < y && polygon[i][0] >= y)
+        ) {
+            if (
+                polygon[i][1] +
+                    ((y - polygon[i][0]) / (polygon[j][0] - polygon[i][0])) *
+                        (polygon[j][1] - polygon[i][1]) <
+                x
+            ) {
+                oddNodes = !oddNodes;
+            }
+        }
+    }
+    return oddNodes;
+};
+
+export const validateLatLng = (lat, lng) => {
+    return validationLatitudeLongitude.latLong(lat, lng);
+};
+
+export const getMetersPerPixelAndZoom = (map, centerLatLng, size) => {
+    var pointC = map.latLngToContainerPoint(centerLatLng);
+    var pointX = [pointC.x + size, pointC.y]; // add one pixel to x
+    var pointY = [pointC.x, pointC.y + size]; // add one pixel to y
+
+    // convert containerpoints to latlng's
+    var latLngC = map.containerPointToLatLng(pointC);
+    var latLngX = map.containerPointToLatLng(pointX);
+    var latLngY = map.containerPointToLatLng(pointY);
+
+    var distanceX = latLngC.distanceTo(latLngX); // calculate distance between c and x (latitude)
+    var distanceY = latLngC.distanceTo(latLngY); // calculate distance between c and y (longitude)
+
+    return {
+        x: distanceX,
+        y: distanceY,
+    };
+};
+
+export const leadZero = (num, padding) => {
+    var len = (parseInt(num) + "").length;
+    if (padding > len) {
+        return new Array(padding - len + 1).join("0") + num;
+    }
+    return num + "";
+};
+
+export const decimalToDecialDegrees = (dec) => {
+    return numeral(dec).format("0.000000");
+};
+
+export const decimalToDecimalMinutesSeconds = (dec) => {
+    if (dec === undefined || dec === null) return dec;
+
+    var sign = dec > 0 ? "" : "-",
+        dec = Math.abs(dec),
+        decRnd = Math.floor(dec);
+
+    const min = (dec - decRnd) * 60.0,
+        minRnd = Math.floor(min);
+
+    return (
+        sign +
+        decRnd +
+        " " +
+        leadZero(minRnd, 2) +
+        " " +
+        leadZero(numeral((min - minRnd) * 60.0).format("0.00"), 2)
+    );
+};
+export const decimalDegreeMinutesToDecimalDegrees = (strVal) => {
+    if (strVal === undefined || strVal === null) return strVal;
+
+    var dm = strVal.split(/\s/);
+    var dec = parseInt(dm[0]);
+
+    var sign = dec < 0 ? -1 : 1,
+        deg = Math.abs(dec),
+        mm = parseFloat(dm[1]) || 0;
+    return sign * (deg + mm / 60.0);
+};
+export const decimalToDecimalDegreeMinutes = (dec) => {
+    if (dec === undefined || dec === null) return dec;
+
+    var sign = dec > 0 ? "" : "-",
+        dec = Math.abs(dec),
+        decRnd = Math.floor(dec);
+
+    return (
+        sign +
+        decRnd +
+        "°" +
+        leadZero(numeral((dec - decRnd) * 60.0).format("0.0000"), 2)
+    );
+};
+
+export const FORMAT = {
+    DDM: "DDM",
+    DD: "DD",
+    DMS: "DMS",
+};
+
+export const formatCoord = (dec, format) => {
+    switch (format) {
+        case FORMAT.DMS:
+            return decimalToDecimalMinutesSeconds(dec);
+        case FORMAT.DDM:
+            return decimalToDecimalDegreeMinutes(dec);
+        default:
+            return decimalToDecialDegrees(dec);
+    }
+}
+
+export const getVerticalHeight =(percent)=>{
+    var h = Math.max(
+        document.documentElement.clientHeight,
+        window.innerHeight || 0
+    );
+    return (percent * h) / 100;
+}
+
+/**
+ * Feature array needs to include latitude and longitudes
+ */
+export const InBounds = (bounds,features)=>{
+
+    const inBoundsFeatures = [];
+
+    features.forEach(clusterGroup=>{
+        if(!clusterGroup.enabled) return;
+        const features = clusterGroup.features;
+
+        for (let i = 0; i < features.length; i++) {
+            const feature = features[i];
+
+            if(bounds.contains([feature.latitude,feature.longitude])){
+                inBoundsFeatures.push(feature);
+            }
+
+        }
+    })
+
+    return inBoundsFeatures;
+}
+
+export const getCircleBounds = (radius,center,map)=>{
+    const metresPerPixel = 40075016.686 * Math.abs(Math.cos(map.getCenter().lat * Math.PI/180)) / Math.pow(2, map.getZoom()+8);
+    const meters = radius * metresPerPixel;
+
+    const circle = L.circle(center,{radius:meters}).addTo(map);
+    const bounds = circle.getBounds();
+    circle.removeFrom(map);
+
+    return bounds;
+
+}

package/lib/utils/NumberUtils.js

@@ -0,0 +1,22 @@
+import numeral from "numeral";
+
+export const convertTo0To1 = ( value ) => {
+    const OldRange = ( 100 - 0 )
+    const NewRange = ( 1 - 0 )
+
+    if ( value === null || value === undefined ) return value;
+
+    return ( ( ( value - 0 ) * NewRange ) / OldRange ) + 0
+}
+
+
+export const formatPhone = (value ) => {
+
+    return numeral( value ).format( '(NNN) NNN-NNNN' )
+
+}
+export const formatColumnCurrency = ( data, value ) => {
+
+    return numeral( value ).format( '$0,0.00' )
+
+}

package/lib/utils/ObjUtils.js

@@ -0,0 +1,75 @@
+/* eslint-disable no-self-compare */
+function is( x, y ) {
+
+
+    if ( x === y ) {
+
+        return x !== 0 || y !== 0 || 1 / x === 1 / y
+
+    } else {
+
+        return x !== x && y !== y
+
+    }
+
+
+}
+const hasOwn = Object.prototype.hasOwnProperty;
+
+
+export function shallowEqual( objA, objB ) {
+
+
+    if ( is( objA, objB ) ) return true
+
+    if (
+        typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null
+    ) {
+        return false
+    }
+
+    const keysA = Object.keys( objA )
+    const keysB = Object.keys( objB )
+
+    if ( keysA.length !== keysB.length ) return false
+
+    for ( let i = 0; i < keysA.length; i++ ) {
+
+        if ( !hasOwn.call( objB, keysA[i] ) || !is( objA[keysA[i]], objB[keysA[i]] ) ) {
+            return false
+        }
+
+    }
+
+    return true
+
+
+}
+
+
+export const getType = ( type ) => {
+    return Object.prototype.toString.call( type );
+};
+
+export const isFunc = ( type ) => getType( type ) === "[object Function]";
+
+
+export const getID = ( entity, prop ) => {
+    const match = entity[prop] || entity?._links[prop]?.href;
+
+    if ( !match ) return null;
+
+    if ( match.indexOf( "http" ) >= 0 ) {
+
+        const strArray = match.split( "/" );
+        return strArray[strArray.length - 1];
+
+    }
+}
+
+export const isEmptyObject = (obj)=>{
+    return Object.keys(obj).length === 0;
+}