@hestia-earth/utils 0.17.15 → 0.17.16

package/dist/esm/array.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Return list of unique values.
+ *
+ * @param values List of values
+ */
+export declare const unique: <T>(values: T[]) => T[];
+/**
+ * Return an array containing all values that appear in both arrays.
+ *
+ * @param array1 List of values
+ * @param array2 List of values
+ */
+export declare const intersection: <T>(array1: T[], array2: T[]) => T[];
+/**
+ * Checks if both arrays are equal.
+ *
+ * @param array1 List of values
+ * @param array2 List of values
+ */
+export declare const isEqual: <T>(array1: T[], array2: T[]) => boolean;

package/dist/esm/array.js

@@ -0,0 +1,49 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * Return list of unique values.
+ *
+ * @param values List of values
+ */
+export var unique = function (values) {
+    return values.some(function (v) { return typeof v === 'object'; })
+        ? __spreadArray([], __read(new Set(values.map(function (v) { return JSON.stringify(v); }))), false).map(function (v) { return JSON.parse(v); })
+        : __spreadArray([], __read(new Set(values)), false);
+};
+/**
+ * Return an array containing all values that appear in both arrays.
+ *
+ * @param array1 List of values
+ * @param array2 List of values
+ */
+export var intersection = function (array1, array2) { return array1.filter(function (x) { return array2.includes(x); }); };
+/**
+ * Checks if both arrays are equal.
+ *
+ * @param array1 List of values
+ * @param array2 List of values
+ */
+export var isEqual = function (array1, array2) { return JSON.stringify(array1) === JSON.stringify(array2); };

package/dist/esm/bin/bin-validate-terms.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/esm/bin/bin-validate-terms.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+import { run } from '../validate-terms';
+run()
+    .then(function (paths) {
+    console.log('Done validating', paths.length, 'files.');
+    console.log(paths.join('\n'));
+    process.exit(0);
+})
+    .catch(function (err) {
+    console.log('Error validating files.');
+    console.error(err);
+    process.exit(1);
+});

package/dist/esm/boolean.d.ts

@@ -0,0 +1 @@
+export declare const isBoolean: (value?: any) => boolean;

package/dist/esm/boolean.js

@@ -0,0 +1,3 @@
+export var isBoolean = function (value) {
+    return typeof value === 'boolean' || "".concat(value).toLowerCase() === 'true' || "".concat(value).toLowerCase() === 'false';
+};

package/dist/esm/date.d.ts

@@ -0,0 +1,59 @@
+export declare const secondMs = 1000;
+export declare const minuteMs: number;
+export declare const hourMs: number;
+export declare const dayMs: number;
+/**
+ * Get the difference in days between two dates.
+ *
+ * @param date1 The left date
+ * @param date2 The right date
+ *
+ * @returns The difference between date1 and date2 in days (rounded).
+ */
+export declare const diffInDays: (date1: Date | string, date2: Date | string) => number;
+/**
+ * Get the difference in years between two dates.
+ *
+ * @param date1 The left date
+ * @param date2 The right date
+ *
+ * @returns The difference between date1 and date2 in years (precision: 1).
+ */
+export declare const diffInYears: (date1: Date | string, date2: Date | string) => number;
+/**
+ * Remove months on the date.
+ *
+ * @param date The date.
+ * @param days How many months to remove. Note: you can use a negative number to add months.
+ *
+ * @returns New date.
+ */
+export declare const monthsBefore: (date?: Date, months?: number) => Date;
+/**
+ * Remove days on the date.
+ *
+ * @param date The date.
+ * @param days How many days to remove. Note: you can use a negative number to add days.
+ *
+ * @returns New date.
+ */
+export declare const daysBefore: (date?: Date, days?: number) => Date;
+/**
+ * Remove hours on the date.
+ *
+ * @param date The date.
+ * @param minutes How many hours to remove. Note: you can use a negative number to add hours.
+ *
+ * @returns New date.
+ */
+export declare const hoursBefore: (date?: Date, hours?: number) => Date;
+/**
+ * Remove minutes on the date.
+ *
+ * @param date The date.
+ * @param minutes How many minutes to remove. Note: you can use a negative number to add minutes.
+ *
+ * @returns New date.
+ */
+export declare const minutesBefore: (date?: Date, minutes?: number) => Date;
+export declare const duration: (timeInMs: number, includeMs?: boolean) => string;

package/dist/esm/date.js

@@ -0,0 +1,108 @@
+export var secondMs = 1000;
+export var minuteMs = 60 * secondMs;
+export var hourMs = 60 * minuteMs;
+export var dayMs = 24 * hourMs;
+var year = 365.2425;
+/**
+ * Get the difference in days between two dates.
+ *
+ * @param date1 The left date
+ * @param date2 The right date
+ *
+ * @returns The difference between date1 and date2 in days (rounded).
+ */
+export var diffInDays = function (date1, date2) {
+    return Math.abs(Math.round((new Date(date2).getTime() - new Date(date1).getTime()) / dayMs));
+};
+/**
+ * Get the difference in years between two dates.
+ *
+ * @param date1 The left date
+ * @param date2 The right date
+ *
+ * @returns The difference between date1 and date2 in years (precision: 1).
+ */
+export var diffInYears = function (date1, date2) {
+    return Math.round((diffInDays(date1, date2) / year) * 10) / 10;
+};
+/**
+ * Remove months on the date.
+ *
+ * @param date The date.
+ * @param days How many months to remove. Note: you can use a negative number to add months.
+ *
+ * @returns New date.
+ */
+export var monthsBefore = function (date, months) {
+    if (date === void 0) { date = new Date(); }
+    if (months === void 0) { months = 1; }
+    var newDate = new Date(date);
+    newDate.setMonth(date.getMonth() - months);
+    return newDate;
+};
+/**
+ * Remove days on the date.
+ *
+ * @param date The date.
+ * @param days How many days to remove. Note: you can use a negative number to add days.
+ *
+ * @returns New date.
+ */
+export var daysBefore = function (date, days) {
+    if (date === void 0) { date = new Date(); }
+    if (days === void 0) { days = 1; }
+    var newDate = new Date(date);
+    newDate.setDate(date.getDate() - days);
+    return newDate;
+};
+/**
+ * Remove hours on the date.
+ *
+ * @param date The date.
+ * @param minutes How many hours to remove. Note: you can use a negative number to add hours.
+ *
+ * @returns New date.
+ */
+export var hoursBefore = function (date, hours) {
+    if (date === void 0) { date = new Date(); }
+    if (hours === void 0) { hours = 1; }
+    var newDate = new Date(date);
+    newDate.setHours(date.getHours() - hours);
+    return newDate;
+};
+/**
+ * Remove minutes on the date.
+ *
+ * @param date The date.
+ * @param minutes How many minutes to remove. Note: you can use a negative number to add minutes.
+ *
+ * @returns New date.
+ */
+export var minutesBefore = function (date, minutes) {
+    if (date === void 0) { date = new Date(); }
+    if (minutes === void 0) { minutes = 1; }
+    var newDate = new Date(date);
+    newDate.setMinutes(date.getMinutes() - minutes);
+    return newDate;
+};
+var parseTime = function (timeInMs) { return ({
+    milliseconds: Math.floor(timeInMs % 1000),
+    seconds: Math.floor((timeInMs / 1000) % 60),
+    minutes: Math.floor((timeInMs / (1000 * 60)) % 60),
+    hours: Math.floor((timeInMs / (1000 * 60 * 60)) % 24),
+    days: Math.floor(timeInMs / (1000 * 60 * 60 * 24))
+}); };
+var formatValue = function (value, suffix) { return (value ? "".concat(value).concat(suffix) : ''); };
+export var duration = function (timeInMs, includeMs) {
+    if (includeMs === void 0) { includeMs = false; }
+    var _a = parseTime(timeInMs), milliseconds = _a.milliseconds, seconds = _a.seconds, minutes = _a.minutes, hours = _a.hours, days = _a.days;
+    return [
+        formatValue(days, 'd'),
+        formatValue(hours, 'h'),
+        formatValue(minutes, 'm'),
+        formatValue(seconds, 's'),
+        includeMs ? formatValue(milliseconds, 'ms') : ''
+    ]
+        .filter(function (v) { return v !== ''; })
+        .join(' ');
+};

package/dist/esm/delta.d.ts

@@ -0,0 +1,32 @@
+import { propertyValueType } from './term';
+export declare enum DeltaDisplayType {
+    absolute = "absolute",
+    percent = "percent"
+}
+type deltaTypeMapping = {
+    [type in DeltaDisplayType]?: (value: number, original: number) => number;
+};
+export declare const customDeltaFuncs: {
+    percent: (recalculated: number, original: number) => number;
+};
+/**
+ * Calculate the delta between 2 values.
+ *
+ * @param value
+ * @param originalValue
+ * @param displayType
+ * @param mapping
+ * @param termId If calculating delta for a specific Term.
+ * @returns
+ */
+export declare const delta: (value: any, originalValue: any, displayType?: DeltaDisplayType, mapping?: deltaTypeMapping, termId?: string) => number;
+/**
+ * Calculate the delta between original and recalculated
+ *
+ * @returns
+ */
+export declare const recalculatedDelta: ({ original, recalculated }: {
+    original: propertyValueType;
+    recalculated: propertyValueType;
+}) => number;
+export {};

package/dist/esm/delta.js

@@ -0,0 +1,78 @@
+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 _a, _b, _c, _d;
+import { emptyValue, propertyValue } from './term';
+import { toPrecision } from './number';
+export var DeltaDisplayType;
+(function (DeltaDisplayType) {
+    DeltaDisplayType["absolute"] = "absolute";
+    DeltaDisplayType["percent"] = "percent";
+})(DeltaDisplayType || (DeltaDisplayType = {}));
+var deltaPerType = (_a = {},
+    _a[DeltaDisplayType.absolute] = function (value, original) { return value - original; },
+    _a[DeltaDisplayType.percent] = function (value, original) { return ((value - original) / original) * 100; },
+    _a);
+var PercentDeltaConditions;
+(function (PercentDeltaConditions) {
+    PercentDeltaConditions["recalculated0"] = "recalculated should be 0";
+    PercentDeltaConditions["original0"] = "original is 0";
+})(PercentDeltaConditions || (PercentDeltaConditions = {}));
+var calculatePercentDeltaConditions = (_b = {},
+    _b[PercentDeltaConditions.recalculated0] = function (original, recalculated) { return original > 0 && recalculated === 0; },
+    _b[PercentDeltaConditions.original0] = function (original, recalculated) { return original === 0 && recalculated > 0; },
+    _b);
+var calculatePercentDeltaResult = (_c = {},
+    _c[PercentDeltaConditions.recalculated0] = function (original, recalculated) { return (recalculated - original) / (original + 1); },
+    // Always considered an error so deliberately exceed SUCCESS_CRITERION_MAX_DELTA_PERCENT
+    _c[PercentDeltaConditions.original0] = function (original, recalculated) { return Math.sign(recalculated - original); },
+    _c.default = function (original, recalculated) { return (recalculated - original) / original; },
+    _c);
+var calculatePercentDelta = function (recalculated, original) {
+    var matchingCondition = Object.values(PercentDeltaConditions).find(function (value) {
+        return calculatePercentDeltaConditions[value](original, recalculated);
+    }) || 'default';
+    return calculatePercentDeltaResult[matchingCondition](original, recalculated) * 100;
+};
+export var customDeltaFuncs = (_d = {},
+    _d[DeltaDisplayType.percent] = calculatePercentDelta,
+    _d);
+/**
+ * Calculate the delta between 2 values.
+ *
+ * @param value
+ * @param originalValue
+ * @param displayType
+ * @param mapping
+ * @param termId If calculating delta for a specific Term.
+ * @returns
+ */
+export var delta = function (value, originalValue, displayType, mapping, termId) {
+    if (displayType === void 0) { displayType = DeltaDisplayType.percent; }
+    var vvalue = toPrecision(propertyValue(value, termId));
+    var voriginalValue = toPrecision(propertyValue(originalValue, termId));
+    var deltaFuncs = __assign(__assign({}, deltaPerType), mapping);
+    var diff = vvalue === voriginalValue ? 0 : deltaFuncs[displayType](vvalue, voriginalValue);
+    return Number.isFinite(diff) ? (diff === -0 ? 0 : diff) : 0;
+};
+/**
+ * Calculate the delta between original and recalculated
+ *
+ * @returns
+ */
+export var recalculatedDelta = function (_a) {
+    var original = _a.original, recalculated = _a.recalculated;
+    return emptyValue(original)
+        ? 0
+        : emptyValue(recalculated)
+            ? 100 // If original value but no recalculated value trigger test failure
+            : delta(recalculated, original, undefined, customDeltaFuncs);
+};

package/dist/esm/form.d.ts

@@ -0,0 +1 @@
+export declare const filterParams: (obj: any) => {};

package/dist/esm/form.js

@@ -0,0 +1,18 @@
+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);
+};
+import { isUndefined } from './utils';
+export var filterParams = function (obj) {
+    return Object.keys(obj).reduce(function (prev, key) {
+        var _a;
+        return (__assign(__assign({}, prev), (isUndefined(obj[key]) || obj[key] === '' ? {} : (_a = {}, _a[key] = "".concat(obj[key]), _a))));
+    }, {});
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from './array';
+export * from './boolean';
+export * from './date';
+export * from './form';
+export * from './number';
+export * from './string';
+export * from './utils';

package/dist/esm/number.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Check if the value is a number.
+ *
+ * @param n Number as string or number
+ * @returns true if the value is a number, false otherwise
+ */
+export declare const isNumber: (n: string | number) => boolean;
+/**
+ * Returns a number with significant figures.
+ * Example: 3645.875 with 3 significant figures will return 3650.
+ *
+ * @param n The value
+ * @param precision The number of significant figures
+ */
+export declare const toPrecision: (n: number, precision?: number) => number;
+/**
+ * Get the value of an array for a given percentile.
+ *
+ * @param values
+ * @param percentile
+ * @returns
+ */
+export declare const getPercentileValue: (values: number[], percentile: number) => number;
+/**
+ * Returns the number formatted with commas every thousand.
+ *
+ * @param n The value
+ */
+export declare const toComma: (n: number) => string;
+export declare enum ConvertUnits {
+    m3 = "m3",
+    kg = "kg",
+    L = "L",
+    MJ = "MJ",
+    kWh = "kWh",
+    kgCa = "kg Ca",
+    kgCaCO3 = "kg CaCO3",
+    kgCaO = "kg CaO",
+    kgCaMg_CO3_2 = "kg CaMg(CO3)2",
+    kgCa_OH_2 = "kg Ca(OH)2",
+    kgCH4 = "kg CH4",
+    kgCH4C = "kg CH4-C",
+    kgCO2 = "kg CO2",
+    kgCO2C = "kg CO2-C",
+    kgK = "kg K",
+    kgK2O = "kg K2O",
+    kgMgCO3 = "kg MgCO3",
+    kgN2 = "kg N2",
+    kgN2N = "kg N2-N",
+    kgN2O = "kg N2O",
+    kgN2ON = "kg N2O-N",
+    kgNH3 = "kg NH3",
+    kgNH3N = "kg NH3-N",
+    kgNH4 = "kg NH4",
+    kgNH4N = "kg NH4-N",
+    kgNO2 = "kg NO2",
+    kgNO2N = "kg NO2-N",
+    kgNO3 = "kg NO3",
+    kgNO3N = "kg NO3-N",
+    kgNOx = "kg NOx",
+    kgNOxN = "kg NOx-N",
+    kgP = "kg P",
+    kgP2O5 = "kg P2O5",
+    kgPO43 = "kg PO43"
+}
+export interface IConvertArgs {
+    density?: number;
+}
+export declare const converters: {
+    [fromUnit in ConvertUnits]?: {
+        [toUnit in ConvertUnits]?: (value: number, args: IConvertArgs) => number;
+    };
+};
+/**
+ * Converts a value of unit into a different unit.
+ * Depending on the destination unit, additional arguments might be provided.
+ *
+ * @param n The value to convert, usually a float or an integer.
+ * @param fromUnit The unit the value is specified in.
+ * @param toUnit The unit the converted value should be.
+ * @param args Optional arguments to provide depending on the conversion.
+ * @returns The converted value.
+ */
+export declare const convertValue: (n: number, fromUnit: ConvertUnits, toUnit: ConvertUnits, args?: IConvertArgs) => number;
+export declare const sum: (values?: number[]) => number;
+export declare const mean: (values?: number[]) => number;
+export declare const min: (values: number[]) => number;
+export declare const max: (values: number[]) => number;
+export declare const median: (values: number[]) => number;