@hestia-earth/utils 0.17.15 → 0.17.17

package/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/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/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/esm/validate-terms.js

@@ -0,0 +1,267 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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));
+};
+import { promises } from 'fs';
+import { join } from 'path';
+import { request } from 'https';
+import { unique } from './array';
+var API_URL = process.env.API_URL || 'https://api.hestia.earth';
+var _a = __read(process.argv.slice(2), 2), folder = _a[0], extension = _a[1];
+var readdir = promises.readdir, lstat = promises.lstat, readFile = promises.readFile;
+var encoding = 'utf8';
+var Term = /** @class */ (function () {
+    function Term() {
+    }
+    return Term;
+}());
+var search = function (body) {
+    return new Promise(function (resolve, reject) {
+        var req = request("".concat(API_URL, "/terms/search"), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' }
+        }, function (res) {
+            res.setEncoding(encoding);
+            var data = [];
+            res.on('data', function (chunk) { return data.push(chunk); });
+            res.on('end', function () { return resolve(JSON.parse(data.join(''))); });
+            res.on('error', reject);
+        });
+        req.write(JSON.stringify(body));
+        req.end();
+    });
+};
+var recursiveFiles = function (directory) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _b = (_a = Promise).all;
+                return [4 /*yield*/, readdir(directory)];
+            case 1: return [4 /*yield*/, _b.apply(_a, [(_c.sent()).map(function (entry) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0: return [4 /*yield*/, lstat(join(directory, entry))];
+                                case 1:
+                                    if (!(_b.sent()).isDirectory()) return [3 /*break*/, 3];
+                                    return [4 /*yield*/, recursiveFiles(join(directory, entry))];
+                                case 2:
+                                    _a = _b.sent();
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    _a = join(directory, entry).endsWith(".".concat(extension || 'jsonld'))
+                                        ? [join(directory, entry)]
+                                        : [];
+                                    _b.label = 4;
+                                case 4: return [2 /*return*/, _a];
+                            }
+                        });
+                    }); })])];
+            case 2: return [2 /*return*/, (_c.sent()).flat()];
+        }
+    });
+}); };
+var getAllTerms = function (data) {
+    return Object.keys(data)
+        .filter(function (key) { return Array.isArray(data[key]) || (typeof data[key] === 'object' && '@type' in data[key]); })
+        .flatMap(function (key) {
+        var value = data[key];
+        var isArray = Array.isArray(value);
+        return isArray ? value.flatMap(getAllTerms) : value['@type'] === 'Term' ? value : getAllTerms(value);
+    })
+        .filter(function (term) { return !!term && term['@type'] === 'Term' && (!!term['@id'] || !!term.name); });
+};
+// search is limited to 1000 parameters
+var searchLimit = 500;
+var searchTerms = function (terms) { return __awaiter(void 0, void 0, void 0, function () {
+    var searchedTerms, results, _a, _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                searchedTerms = terms.slice(0, searchLimit);
+                if (!searchedTerms.length) return [3 /*break*/, 2];
+                return [4 /*yield*/, search({
+                        limit: searchLimit,
+                        fields: ['@id', 'name'],
+                        query: {
+                            bool: {
+                                must: [
+                                    {
+                                        match: { '@type': 'Term' }
+                                    }
+                                ],
+                                should: searchedTerms.map(function (_a) {
+                                    var id = _a["@id"], name = _a.name;
+                                    return ({
+                                        match: id ? { '@id.keyword': id } : { 'name.keyword': name }
+                                    });
+                                }),
+                                minimum_should_match: 1
+                            }
+                        }
+                    })];
+            case 1:
+                _a = _d.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                _a = { results: [] };
+                _d.label = 3;
+            case 3:
+                results = (_a).results;
+                _b = [__spreadArray([], __read(results), false)];
+                if (!(terms.length > searchLimit)) return [3 /*break*/, 5];
+                return [4 /*yield*/, searchTerms(terms.slice(searchLimit))];
+            case 4:
+                _c = _d.sent();
+                return [3 /*break*/, 6];
+            case 5:
+                _c = [];
+                _d.label = 6;
+            case 6: return [2 /*return*/, __spreadArray.apply(void 0, _b.concat([__read.apply(void 0, [(_c)]), false]))];
+        }
+    });
+}); };
+/**
+ * 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 var validateTerms = function (terms) { return __awaiter(void 0, void 0, void 0, function () {
+    var results;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, searchTerms(terms)];
+            case 1:
+                results = _a.sent();
+                return [2 /*return*/, terms
+                        .map(function (_a) {
+                        var id = _a["@id"], name = _a.name;
+                        var exists = results.find(function (res) { return res['@id'] === id || res.name === name; });
+                        return exists ? true : id || name;
+                    })
+                        .filter(function (val) { return val !== true; })];
+        }
+    });
+}); };
+var validateFile = function (existingTerms) {
+    return function (_a) {
+        var filepath = _a.filepath, terms = _a.terms;
+        return ({
+            filepath: filepath,
+            missing: terms
+                .map(function (_a) {
+                var id = _a["@id"], name = _a.name;
+                return existingTerms.find(function (res) { return res['@id'] === id || res.name === name; }) ? true : id || name;
+            })
+                .filter(function (val) { return val !== true; })
+        });
+    };
+};
+var loadFile = function (filepath) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, _b, _c;
+    var _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _d = {
+                    filepath: filepath
+                };
+                _a = getAllTerms;
+                _c = (_b = JSON).parse;
+                return [4 /*yield*/, readFile(filepath, encoding)];
+            case 1: return [2 /*return*/, (_d.terms = _a.apply(void 0, [_c.apply(_b, [_e.sent()])]),
+                    _d)];
+        }
+    });
+}); };
+export var run = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var filepaths, fileData, allTerms, existingTerms, results, missingFiles;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, recursiveFiles(folder)];
+            case 1:
+                filepaths = _a.sent();
+                return [4 /*yield*/, Promise.all(filepaths.map(loadFile))];
+            case 2:
+                fileData = _a.sent();
+                allTerms = unique(fileData.flatMap(function (_a) {
+                    var terms = _a.terms;
+                    return terms;
+                }));
+                return [4 /*yield*/, searchTerms(allTerms)];
+            case 3:
+                existingTerms = _a.sent();
+                results = fileData.map(validateFile(existingTerms)).filter(Boolean);
+                missingFiles = results.filter(function (_a) {
+                    var missing = _a.missing;
+                    return missing.length;
+                });
+                if (missingFiles.length) {
+                    throw new Error("\n  Terms not found:\n  \t".concat(missingFiles.map(function (_a) {
+                        var filepath = _a.filepath, missing = _a.missing;
+                        return "- ".concat(filepath, ": ").concat(missing.join(', '));
+                    }).join('\n\t'), "\n    ").trim());
+                }
+                return [2 /*return*/, filepaths];
+        }
+    });
+}); };

package/form.d.ts

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

package/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/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;

package/package.json

@@ -1,14 +1,33 @@
 {
   "name": "@hestia-earth/utils",
-  "version": "0.17.15",
+  "version": "0.17.17",
   "description": "HESTIA Utils library",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./*.js": {
+      "types": "./*.d.ts",
+      "import": "./esm/*.js",
+      "require": "./*.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./esm/*.js",
+      "require": "./*.js"
+    }
+  },
+  "sideEffects": false,
   "bin": {
-    "hestia-validate-terms": "dist/bin/bin-validate-terms.js"
+    "hestia-validate-terms": "bin/bin-validate-terms.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.dist.json",
+    "build": "rm -rf dist && tsc -p tsconfig.dist.json && tsc -p tsconfig.dist.esm.json && cp package.json README.md dist/",
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "npm run lint -- --fix",
     "test": "jest",