@hestia-earth/utils 0.17.14 → 0.17.16

package/dist/esm/number.js

@@ -0,0 +1,218 @@
+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 _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+/**
+ * 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 var isNumber = function (n) {
+    var _a;
+    return [(_a = /^(-)?[\d\.]+((e|e-)[\d]+)?$/.exec("".concat(n))) === null || _a === void 0 ? void 0 : _a.length, !isNaN(parseFloat("".concat(n))), isFinite(parseFloat("".concat(n)))].every(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 var toPrecision = function (n, precision) {
+    if (precision === void 0) { precision = 3; }
+    // Use Math.log10 for better accuracy
+    var logN = Math.log10(Math.abs(n));
+    // Use a small epsilon to handle floating point errors in log10
+    var floorLogN = Math.floor(logN + 1e-13);
+    var mult = Math.pow(10, precision - floorLogN - 1);
+    var cappedMultiplied = 0.0001;
+    return n === 0
+        ? 0
+        : !isNumber(n)
+            ? undefined
+            : mult < cappedMultiplied
+                ? Math.round(n * cappedMultiplied) / cappedMultiplied
+                : Number(n.toPrecision(precision));
+};
+/**
+ * Get the value of an array for a given percentile.
+ *
+ * @param values
+ * @param percentile
+ * @returns
+ */
+export var getPercentileValue = function (values, percentile) {
+    var sorted = values.slice().sort(function (a, b) { return a - b; });
+    var index = (sorted.length - 1) * percentile;
+    var lower = Math.floor(index);
+    var upper = Math.ceil(index);
+    var weight = index - lower;
+    return lower === upper ? sorted[index] : sorted[lower] * (1 - weight) + sorted[upper] * weight;
+};
+/**
+ * Returns the number formatted with commas every thousand.
+ *
+ * @param n The value
+ */
+export var toComma = function (n) {
+    var _a = __read(n.toString().split('.'), 2), numberPart = _a[0], decimalPart = _a[1];
+    var thousands = /\B(?=(\d{3})+(?!\d))/g;
+    return "".concat(numberPart.replace(thousands, ',')).concat(decimalPart ? ".".concat(decimalPart) : '');
+};
+var C = 12.012;
+var CA = 40.078;
+var H = 1.008;
+var K = 39.098;
+var N = 14.007;
+var O = 15.999;
+var P = 30.974;
+export var ConvertUnits;
+(function (ConvertUnits) {
+    ConvertUnits["m3"] = "m3";
+    ConvertUnits["kg"] = "kg";
+    ConvertUnits["L"] = "L";
+    ConvertUnits["MJ"] = "MJ";
+    ConvertUnits["kWh"] = "kWh";
+    ConvertUnits["kgCa"] = "kg Ca";
+    ConvertUnits["kgCaCO3"] = "kg CaCO3";
+    ConvertUnits["kgCaO"] = "kg CaO";
+    ConvertUnits["kgCaMg_CO3_2"] = "kg CaMg(CO3)2";
+    ConvertUnits["kgCa_OH_2"] = "kg Ca(OH)2";
+    ConvertUnits["kgCH4"] = "kg CH4";
+    ConvertUnits["kgCH4C"] = "kg CH4-C";
+    ConvertUnits["kgCO2"] = "kg CO2";
+    ConvertUnits["kgCO2C"] = "kg CO2-C";
+    ConvertUnits["kgK"] = "kg K";
+    ConvertUnits["kgK2O"] = "kg K2O";
+    ConvertUnits["kgMgCO3"] = "kg MgCO3";
+    ConvertUnits["kgN2"] = "kg N2";
+    ConvertUnits["kgN2N"] = "kg N2-N";
+    ConvertUnits["kgN2O"] = "kg N2O";
+    ConvertUnits["kgN2ON"] = "kg N2O-N";
+    ConvertUnits["kgNH3"] = "kg NH3";
+    ConvertUnits["kgNH3N"] = "kg NH3-N";
+    ConvertUnits["kgNH4"] = "kg NH4";
+    ConvertUnits["kgNH4N"] = "kg NH4-N";
+    ConvertUnits["kgNO2"] = "kg NO2";
+    ConvertUnits["kgNO2N"] = "kg NO2-N";
+    ConvertUnits["kgNO3"] = "kg NO3";
+    ConvertUnits["kgNO3N"] = "kg NO3-N";
+    ConvertUnits["kgNOx"] = "kg NOx";
+    ConvertUnits["kgNOxN"] = "kg NOx-N";
+    ConvertUnits["kgP"] = "kg P";
+    ConvertUnits["kgP2O5"] = "kg P2O5";
+    ConvertUnits["kgPO43"] = "kg PO43";
+})(ConvertUnits || (ConvertUnits = {}));
+export var converters = (_a = {},
+    _a[ConvertUnits.m3] = (_b = {},
+        _b[ConvertUnits.kg] = function (value, args) { return value * args.density; },
+        _b[ConvertUnits.L] = function (value) { return value * 1000; },
+        _b),
+    _a[ConvertUnits.kg] = (_c = {},
+        _c[ConvertUnits.m3] = function (value, args) { return value / args.density; },
+        _c[ConvertUnits.L] = function (value, args) { return (value / args.density) * 1000; },
+        _c),
+    _a[ConvertUnits.L] = (_d = {},
+        _d[ConvertUnits.kg] = function (value, args) { return (value * args.density) / 1000; },
+        _d[ConvertUnits.m3] = function (value) { return value / 1000; },
+        _d),
+    _a[ConvertUnits.kWh] = (_e = {},
+        _e[ConvertUnits.MJ] = function (value) { return value * 3.6; },
+        _e),
+    _a[ConvertUnits.MJ] = (_f = {},
+        _f[ConvertUnits.kWh] = function (value) { return value / 3.6; },
+        _f),
+    _a[ConvertUnits.kgP] = (_g = {},
+        _g[ConvertUnits.kgP2O5] = function (value) { return (value * (P * 2)) / (P * 2 + O * 5); },
+        _g[ConvertUnits.kgPO43] = function (value) { return (value * P) / ((P + O * 4) * 3); },
+        _g),
+    _a[ConvertUnits.kgPO43] = (_h = {},
+        _h[ConvertUnits.kgP2O5] = function (value) { return (value * ((P + O * 4) * 3)) / (P * 2 + O * 5); },
+        _h),
+    _a[ConvertUnits.kgK] = (_j = {},
+        _j[ConvertUnits.kgK2O] = function (value) { return (value * (K * 2)) / (K * 2 + O); },
+        _j),
+    _a[ConvertUnits.kgCa] = (_k = {},
+        _k[ConvertUnits.kgCaO] = function (value) { return (value * CA) / (CA + O); },
+        _k),
+    _a[ConvertUnits.kgCaO] = (_l = {},
+        _l[ConvertUnits.kgCaCO3] = function (value) { return (value * (CA + O)) / (CA + C + O * 3); },
+        _l),
+    _a[ConvertUnits.kgCaMg_CO3_2] = (_m = {},
+        _m[ConvertUnits.kgCaCO3] = function (value) { return value; },
+        _m),
+    _a[ConvertUnits.kgCa_OH_2] = (_o = {},
+        _o[ConvertUnits.kgCaCO3] = function (value) { return value; },
+        _o),
+    _a[ConvertUnits.kgCaCO3] = (_p = {},
+        _p[ConvertUnits.kgCO2] = function (value) { return value * 0.12; },
+        _p),
+    _a[ConvertUnits.kgMgCO3] = (_q = {},
+        _q[ConvertUnits.kgCO2] = function (value) { return value * 0.13; },
+        _q),
+    _a[ConvertUnits.kgCH4] = (_r = {},
+        _r[ConvertUnits.kgCH4C] = function (value) { return (value * (C + H * 4)) / C; },
+        _r),
+    _a[ConvertUnits.kgCO2] = (_s = {},
+        _s[ConvertUnits.kgCO2C] = function (value) { return (value * (C + O * 2)) / C; },
+        _s),
+    _a[ConvertUnits.kgNOx] = (_t = {},
+        _t[ConvertUnits.kgNOxN] = function (value) { return (value * (N + O)) / N; },
+        _t),
+    _a[ConvertUnits.kgN2] = (_u = {},
+        _u[ConvertUnits.kgN2N] = function (value) { return value * 1; },
+        _u),
+    _a[ConvertUnits.kgN2O] = (_v = {},
+        _v[ConvertUnits.kgN2ON] = function (value) { return (value * (N * 2 + O)) / (N * 2); },
+        _v),
+    _a[ConvertUnits.kgNO2] = (_w = {},
+        _w[ConvertUnits.kgNO2N] = function (value) { return (value * (N + O * 2)) / N; },
+        _w),
+    _a[ConvertUnits.kgNO3] = (_x = {},
+        _x[ConvertUnits.kgNO3N] = function (value) { return (value * (N + O * 3)) / N; },
+        _x),
+    _a[ConvertUnits.kgNH3] = (_y = {},
+        _y[ConvertUnits.kgNH3N] = function (value) { return (value * (N + H * 3)) / N; },
+        _y),
+    _a[ConvertUnits.kgNH4] = (_z = {},
+        _z[ConvertUnits.kgNH4N] = function (value) { return (value * (N + H * 4)) / N; },
+        _z),
+    _a);
+/**
+ * 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 var convertValue = function (n, fromUnit, toUnit, args) {
+    return converters[fromUnit][toUnit](n, args);
+};
+export var sum = function (values) {
+    if (values === void 0) { values = []; }
+    return values.reduce(function (p, c) { return p + c; }, 0);
+};
+export var mean = function (values) {
+    if (values === void 0) { values = []; }
+    return ((values === null || values === void 0 ? void 0 : values.length) ? sum(values) / values.length : 0);
+};
+export var min = function (values) { return Math.min.apply(Math.min, values); };
+export var max = function (values) { return Math.max.apply(Math.max, values); };
+export var median = function (values) { return values.sort()[Math.round(values.length / 2)]; };

package/dist/esm/string.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Trims the string to a certain max length and replace with `...`.
+ *
+ * @param text The text to ellipsize.
+ * @param maxlength The maximum length of the text (including `...`).
+ * @returns
+ */
+export declare const ellipsis: (text?: string, maxlength?: number) => string;
+export declare const keyToLabel: (key: string) => string;
+/**
+ * Convert a string to dash-case.
+ *
+ * @param value The original value.
+ * @returns A dash case version of the value.
+ */
+export declare const toDashCase: (value?: string) => string;
+/**
+ * Convert a string to camelCase.
+ *
+ * @param value The original value.
+ * @returns A camel case version of the value.
+ */
+export declare const toCamelCase: (value?: string) => string;
+export declare const dateToString: (date: Date) => string;
+/**
+ * Returns current date in YYYY-MM-DD format.
+ *
+ * @returns Date as a string.
+ */
+export declare const now: () => string;
+/**
+ * Parse a markdown link.
+ *
+ * @param link
+ * @returns Title and link if found.
+ */
+export declare const parseMarkdownLink: (link: string) => {
+    title: string;
+    link: string;
+} | {
+    title: string;
+    link?: undefined;
+};
+/**
+ * Parse a citation.
+ *
+ * @param value
+ * @returns
+ */
+export declare const parseCitation: (value: string) => {
+    original: string;
+    name: string;
+    title: string;
+    link: string;
+};

package/dist/esm/string.js

@@ -0,0 +1,117 @@
+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;
+};
+/**
+ * Trims the string to a certain max length and replace with `...`.
+ *
+ * @param text The text to ellipsize.
+ * @param maxlength The maximum length of the text (including `...`).
+ * @returns
+ */
+export var ellipsis = function (text, maxlength) {
+    if (text === void 0) { text = ''; }
+    if (maxlength === void 0) { maxlength = 20; }
+    return text.length > maxlength ? "".concat(text.substring(0, maxlength), "...") : text;
+};
+export var keyToLabel = function (key) {
+    return "".concat(key[0].toUpperCase()).concat(key
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([_])([a-zA-Z])/g, function (g) { return " ".concat(g[1].toUpperCase()); })
+        .substring(1));
+};
+/**
+ * Convert a string to dash-case.
+ *
+ * @param value The original value.
+ * @returns A dash case version of the value.
+ */
+export var toDashCase = function (value) {
+    return value
+        ? value
+            // handle dates followed by capital letter
+            .replace(/([\d]{4})([A-Z]{1})/g, function (g) { return "".concat(g.substring(0, 4), "-").concat(g[4].toLowerCase()); })
+            // handle words followed by dates
+            .replace(/([A-Za-z]{1})([\d]{4})/g, '$1-$2')
+            // handle molecules
+            .replace(/([\d]{1}[A-Z]{1}?)([A-Z]{1})/g, function (_g) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
+            }
+            return "".concat(args[0], "-").concat(args[1]).toLowerCase();
+        })
+            // handle words followed by numbers
+            .replace(/([A-Z][a-z]+)([0-9]{2,})/g, '$1-$2')
+            // handle all capital letters
+            .replace(/([A-Z])/g, function (g) { return "-".concat(g[0].toLowerCase()); })
+            // handle underscores
+            .replace(/[\_\.]/g, '-')
+        : null;
+};
+/**
+ * Convert a string to camelCase.
+ *
+ * @param value The original value.
+ * @returns A camel case version of the value.
+ */
+export var toCamelCase = function (value) {
+    return value
+        ? value
+            .replace(/^[_.\- ]+/, '')
+            .toLowerCase()
+            .replace(/[_.\- ]+(\w|$)/g, function (_, p1) { return p1.toUpperCase(); })
+            .replace(/\d+(\w|$)/g, function (m) { return m.toUpperCase(); })
+            .replace(/[(),\s]/g, '')
+            .replace(/[>:]/g, '-')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+        : null;
+};
+export var dateToString = function (date) { return date.toJSON().substring(0, 10); };
+/**
+ * Returns current date in YYYY-MM-DD format.
+ *
+ * @returns Date as a string.
+ */
+export var now = function () { return dateToString(new Date()); };
+/**
+ * Parse a markdown link.
+ *
+ * @param link
+ * @returns Title and link if found.
+ */
+export var parseMarkdownLink = function (link) {
+    var regex = /\[(.*?)\]\((.*?)\)/;
+    var match = link.match(regex);
+    return match && match.length === 3 ? { title: match[1], link: match[2] } : { title: link };
+};
+/**
+ * Parse a citation.
+ *
+ * @param value
+ * @returns
+ */
+export var parseCitation = function (value) {
+    var _a, _b;
+    var parsed = parseMarkdownLink(value);
+    var _c = __read(parsed.title.match(/(.*[(]\d+[)][\.|\s])?(.*)/), 3), original = _c[0], name = _c[1], title = _c[2];
+    return {
+        original: original,
+        name: (_a = name === null || name === void 0 ? void 0 : name.trim()) === null || _a === void 0 ? void 0 : _a.replace(/\.$/, ''),
+        title: (_b = title === null || title === void 0 ? void 0 : title.trim()) === null || _b === void 0 ? void 0 : _b.replace(/\.$/, ''),
+        link: parsed.link
+    };
+};

package/dist/esm/term.d.ts

@@ -0,0 +1,21 @@
+export declare enum ArrayTreatment {
+    mean = "mean",
+    sum = "sum",
+    first = "first"
+}
+export type propertyValueType = string | number | boolean | null;
+export declare const arrayValue: (values?: propertyValueType[], arrayTreatment?: ArrayTreatment) => propertyValueType;
+/**
+ * Calculate the final value of a property.
+ *
+ * @param value The value as an array or a string/number/boolean.
+ * @param termId Optional - us if the term should handle an array in a specific way.
+ */
+export declare const propertyValue: (value: propertyValueType | propertyValueType[], termId?: string) => propertyValueType;
+/**
+ * Checks if the value is empty or if the property value is empty.
+ *
+ * @param value
+ * @returns
+ */
+export declare const emptyValue: (value: propertyValueType, termId?: string) => boolean;

package/dist/esm/term.js

@@ -0,0 +1,52 @@
+import { getArrayTreatment } from '@hestia-earth/glossary';
+import { isEmpty, isUndefined } from './utils';
+import { isNumber } from './number';
+import { isBoolean } from './boolean';
+export var ArrayTreatment;
+(function (ArrayTreatment) {
+    ArrayTreatment["mean"] = "mean";
+    ArrayTreatment["sum"] = "sum";
+    ArrayTreatment["first"] = "first";
+})(ArrayTreatment || (ArrayTreatment = {}));
+var arrayValueByTreatment = {
+    mean: function (values) { return values.reduce(function (prev, curr) { return prev + parseFloat("".concat(curr)); }, 0) / values.length; },
+    sum: function (values) { return values.reduce(function (prev, curr) { return prev + parseFloat("".concat(curr)); }, 0); },
+    first: function (values) { return values[0]; }
+};
+export var arrayValue = function (values, arrayTreatment) {
+    if (values === void 0) { values = []; }
+    if (arrayTreatment === void 0) { arrayTreatment = ArrayTreatment.sum; }
+    var filteredValues = values.filter(function (v) { return !isEmpty(v); });
+    var treatmentFunction = arrayValueByTreatment[arrayTreatment] || arrayValueByTreatment.first;
+    return filteredValues.length === 0
+        ? null
+        : filteredValues.every(isNumber)
+            ? treatmentFunction(filteredValues.filter(function (v) { return typeof v !== 'undefined'; }))
+            : filteredValues.every(isBoolean)
+                ? filteredValues.every(Boolean)
+                : filteredValues.join(';');
+};
+/**
+ * Calculate the final value of a property.
+ *
+ * @param value The value as an array or a string/number/boolean.
+ * @param termId Optional - us if the term should handle an array in a specific way.
+ */
+export var propertyValue = function (value, termId) {
+    return isUndefined(value)
+        ? null
+        : Array.isArray(value)
+            ? arrayValue(value, termId ? getArrayTreatment(termId) : undefined)
+            : isNumber(value)
+                ? parseFloat("".concat(value))
+                : value;
+};
+/**
+ * Checks if the value is empty or if the property value is empty.
+ *
+ * @param value
+ * @returns
+ */
+export var emptyValue = function (value, termId) {
+    return isEmpty(value) || isNaN(propertyValue(value, termId));
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const isEmpty: (value: any, minKeys?: number) => boolean;
+export declare const isIri: (value?: string) => boolean;
+export declare const isUndefined: <T>(value: T, allowNull?: boolean) => boolean;
+export declare const reduceUndefinedValues: <T>(obj: T, allowNull?: boolean) => Partial<T>;
+export declare const filterUndefinedValues: <T>(values: T[], allowNull?: boolean) => T[];

package/dist/esm/utils.js

@@ -0,0 +1,58 @@
+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 __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;
+};
+export var isEmpty = function (value, minKeys) {
+    if (minKeys === void 0) { minKeys = 1; }
+    return value === null ||
+        typeof value === 'undefined' ||
+        (typeof value === 'object'
+            ? Array.isArray(value)
+                ? !value.length
+                : Object.keys(value).filter(function (key) { return key !== 'type'; }).length < minKeys
+            : value === '');
+};
+export var isIri = function (value) { return (value || '').startsWith('http'); };
+/* eslint-disable complexity */
+export var isUndefined = function (value, allowNull) {
+    if (allowNull === void 0) { allowNull = false; }
+    return (value === null && !allowNull) ||
+        typeof value === 'undefined' ||
+        (typeof value === 'object' && value !== null && !(value instanceof Date) && !Object.keys(value).length);
+};
+/* eslint-enable complexity */
+export var reduceUndefinedValues = function (obj, allowNull) {
+    if (allowNull === void 0) { allowNull = false; }
+    return Object.entries(obj).reduce(function (prev, _a) {
+        var _b;
+        var _c = __read(_a, 2), key = _c[0], value = _c[1];
+        return __assign(__assign({}, prev), (isUndefined(value, allowNull) ? {} : (_b = {}, _b[key] = value, _b)));
+    }, {});
+};
+export var filterUndefinedValues = function (values, allowNull) {
+    if (allowNull === void 0) { allowNull = false; }
+    return values.filter(function (value) { return !isUndefined(value, allowNull); });
+};

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

@@ -0,0 +1,13 @@
+declare class Term {
+    '@id': string;
+    name: string;
+}
+/**
+ * Validate a list of Terms.
+ *
+ * @param terms The list of Terms to validate.
+ * @returns The list of ids/names that could not be found (invalid).
+ */
+export declare const validateTerms: (terms: Term[]) => Promise<string[]>;
+export declare const run: () => Promise<string[]>;
+export {};