Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
utils.utils.js Maven / Gradle / Ivy
import React from 'react'
import {
useCallback,
useEffect,
useState } from 'react'
import {
useApolloClient } from '@apollo/client'
import reform from 'immutability-helper'
import { format, parse } from 'date-fns'
import _ from 'lodash'
import Report from 'helpers/report'
import CenteredLoader from 'components/common/CenteredLoader'
import { toRegex } from 'utils/option-utils'
import { nullOrEmpty } from '../components/form/fields/utils/values'
import Types from 'types/types'
// === misc functions === //
const urlRegex =/(\b(https?|ftp|file):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/i
export const isUrl = (str) => urlRegex.test(str) // TODO rename to is*Absolute*Url?
export function addObject(condition, obj) {
return condition ? [obj] : []
}
export function addPromiseStatus(promise) {
// Don't modify any promise that has been already modified.
if (promise.isFulfilled) return promise;
// Set initial state
var isPending = true;
var isRejected = false;
var isFulfilled = false;
// Observe the promise, saving the fulfillment in a closure scope.
var result = promise.then(
function(v) {
isFulfilled = true;
isPending = false;
return v;
},
function(e) {
isRejected = true;
isPending = false;
throw e;
}
);
result.isFulfilled = function() { return isFulfilled; };
result.isPending = function() { return isPending; };
result.isRejected = function() { return isRejected; };
return result;
}
export function env(name) {
const key = 'REACT_APP_' + name
return (global._env && global._env[key]) || process.env[key]
}
export function isString(obj) {
return typeof obj === 'string' || obj instanceof String
}
export const setTimeoutPromise = (cb, delay) =>
new Promise((resolve) => {
setTimeout(() => {
resolve(cb());
}, delay);
});
export function asyncSleep(delay = 0) {
return new Promise((resolve) => {
setTimeout(resolve, delay);
});
}
export function sleep(delay = 0) {
(async () => { await asyncSleep(delay) })()
}
export function toTypeString( obj ) {
return ({}).toString.call( obj ).match(/\s(\w+)/)[1].toLowerCase();
}
export function isOfType(arg, type) {
if (typeof type !== "string")
throw new TypeError("Provide a type specifier, e.g.: 'string!'")
const simpleType = type.replace(/!/g, '').toLowerCase()
const actualType = toTypeString(arg)
return (! /.*!$/.test(type) || arg !== null) && actualType == simpleType;
}
export function assertType(arg, type, msg = "") {
if (!isOfType(arg, type)) {
const defaultMsg = "value '" + arg + "' is not of expected type '" + type + "'."
const message = msg ? msg : defaultMsg
throw new TypeError(message);
}
}
export function assertTypes( args, types ) {
args = [].slice.call( args );
for ( var i = 0; i < types.length; ++i )
assertType(args[i], types[i], i)
}
export function pruneEmpty(obj) {
return function prune(current) {
_.forOwn(current, function (value, key) {
if (_.isUndefined(value) || _.isNull(value) || _.isNaN(value) ||
(Types.isObject(value) && _.isEmpty(prune(value))) ||
(Array.isArray(value) && value.length == 0))
{
delete current[key];
}
});
// remove any leftover undefined values from the delete
// operation on an array
if (_.isArray(current)) _.pull(current, undefined);
return current
}(_.cloneDeep(obj)); // Do not modify the original object, create a clone instead
}
export function hasNonEmptyValue(obj) {
if (Types.isObject(obj))
return Object.values(obj).some(hasNonEmptyValue)
else if (Array.isArray(obj))
return obj.some(hasNonEmptyValue)
else
return !Boolean(isEmptyValue(obj))
}
export function isEmptyValue(value) {
return value === null || value === undefined || value === "" || (Array.isArray(value) && value.length === 0)
}
export function withDefault(value, fallback) {
return isEmptyValue(value) ? fallback : value
}
export function mapSet(set, f) {
var newSet = new Set();
for (var v of set.values()) newSet.add(f(v));
return newSet;
};
export function addLinesAt(lines, index, selected, defaultValue) {
if (!Array.isArray(lines))
return lines
var indexes = Array.from(selected).sort();
const selectedLines = fallback(indexes.map(index => fallback(lines[index], defaultValue)), [defaultValue])
return reform(lines, { $splice: [[index + 1, 0, ...selectedLines]] })
}
export function deleteLinesAt(lines, index, nr) {
if (!Array.isArray(lines))
return lines
return reform(lines, { $splice: [[index, nr]] })
}
export function fallback(value, fallback) {
return nullOrEmpty(value) ? fallback : value
}
// this is the opposite of renderPath. given a rpath produces the 'indices' object expected by renderPath
export function extractIndices(rpath) {
let indices = {}
if (isString(rpath)) {
const matches = rpath.matchAll(/(\w+)\[(\d+)\]/g)
for (const match of matches) {
const name = match[1]
const index = match[2]
indices[name] = parseInt(index)
}
}
return indices
}
export function renderPath(path, indices) {
return path.replace(/\$\w+/g, (matched) => {
const name = matched.substring(1)
const index = indices[name]
//console.log("renderPath(%o): name=%o, index=%o", path, name, index)
return index
});
}
/** @deprecated no longer used */
export function valuesToFormEntries(values) {
return new Array(...values).map(([key, value]) => { return { key, value } })
}
// find the first occurance of 'key' recursively, and return the value
export function findVal(object, key) {
var value;
const resolve = function(k) {
if (k === key) {
value = object[k];
return true;
}
value = findVal(object[k], key);
return value !== undefined;
}
if (Types.isObject(object))
Object.keys(Types.asObject(object)).some(resolve);
return value;
}
export function getPath(obj, path, dflt = undefined) {
if (obj == undefined)
return dflt
else if (path == "")
return obj
else if (!_.isString(path))
throw "Function getPath was provided with an invalid path: '" + path + "'"
else
return _.get(obj, path, dflt)
}
/* paginate data. starting from index 1! */
export function paginate(array, pageSize, page) {
if (Array.isArray(array))
return array.slice(page * pageSize, (page + 1) * pageSize);
else
return []
}
export function handleResults(results, notifier, callback, errorCallbacks) {
const defaultErrorCallback = (error) => {
console.error("GraphQL error: %o", error)
const report = Report.error(Report.backend, Report.code.backend.Error)
report.addToNotifier(notifier)
return report.toNotification({reload: true})
}
if (!Array.isArray(results) || results.some(result => !result.hasOwnProperty('loading'))) {
notifier.error("Function handleResults only accepts an array of graphql queries")
return null
}
const loading = results.some(result => result.loading)
if (loading)
return
