@hestia-earth/schema-convert 37.0.0 → 37.2.0

package/esm/csv-pivot.js

@@ -0,0 +1,21 @@
+import { convertValue, omitKeys, jsonToCsv, uncapitalize } from './utils';
+import { pivotNode } from './json-pivot';
+const parseValue = (value) => {
+    const result = convertValue(value);
+    return typeof result === undefined || result === null ? '' : result.toString();
+};
+const withType = (nodes) => nodes.map(node => ({ [uncapitalize(node['@type'] || node.type)]: node }));
+export const toCsv = (nodes, keys, excludeKeys = omitKeys) => jsonToCsv(withType(nodes), {
+    keys,
+    excludeKeys,
+    emptyFieldValue: '-',
+    parseValue
+});
+/**
+ * CSV format for data processing.
+ *
+ * @pram schemas Schema definitions to use for pivoting.
+ * @param nodes List of nodes to convert.
+ * @returns CSV content formatted with pivoted blank nodes.
+ */
+export const toCsvPivot = (schemas, nodes) => toCsv(nodes.map(node => pivotNode(schemas, node)));

package/esm/csv.js

@@ -0,0 +1,110 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { NodeType } from '@hestia-earth/schema';
+import { loadSchemas } from '@hestia-earth/json-schema';
+import { isCSVIncluded, schemaFromKey } from '@hestia-earth/json-schema/schema-utils';
+const get = require('lodash.get');
+import { isExpandable } from './utils';
+const noValue = '-';
+export const csvColSep = ',';
+const ignoreValues = {
+    Date: val => val instanceof Date,
+    GeoJSON: val => typeof val === 'object' && ('features' in val || 'feature' in val || 'geometry' in val)
+};
+const isIgnored = (val) => Object.values(ignoreValues).some(func => func(val));
+/**
+ * Get the headers in a CSV file.
+ *
+ * @param csv The CSV content as string.
+ * @returns headers as a list.
+ */
+export const headersFromCsv = (csv) => csv.split('\n')[0].split(csvColSep);
+const convertValue = {
+    default: (value) => `${value}`,
+    object: (value) => (value === null ? noValue : value instanceof Date ? value.toJSON() : JSON.stringify(value))
+};
+const escapeField = (value) => {
+    const convertType = typeof value in convertValue ? typeof value : 'default';
+    const val = `${convertValue[convertType](value)}`.replace(/"/g, '""').replace(/\r/g, '').replace('\n', '');
+    return val.includes(csvColSep) ? `"${val}"` : val;
+};
+const skipColumns = ['type', '@type', '@context'];
+const typeToColumnName = (type = '') => `${type.substring(0, 1).toLowerCase()}${type.substring(1)}`;
+const getChildrenHeaders = (key, value, useBrackets) => {
+    const headers = getHeaders(value, useBrackets);
+    return Array.isArray(value)
+        ? headers.map(header => {
+            const [index, ...rest] = header.split('.');
+            return `${key}${useBrackets ? `[${index}]` : `.${index}`}.${rest.join('.')}`;
+        })
+        : headers.map(header => `${key}.${header}`);
+};
+const getHeaders = (node, useBrackets) => Object.keys(node)
+    .flatMap(key => {
+    const value = node[key];
+    return isExpandable(value) && !isIgnored(value) ? getChildrenHeaders(key, value, useBrackets) : key;
+})
+    .filter(key => !skipColumns.includes(key));
+const isIndexedNode = (headers) => {
+    const topLevel = headers.filter(header => !header.includes('.'));
+    return topLevel.some(header => header === '@id');
+};
+const defaultOptions = {
+    includeExising: true,
+    useBrackets: false,
+    includeAllHeaders: false,
+    selectedHeaders: []
+};
+const filterTermHeaders = (schemas, header) => {
+    const { title } = schemaFromKey(schemas, header);
+    return title !== NodeType.Term || header.endsWith('id') || header.endsWith('name');
+};
+const filterHeaders = (headers) => {
+    const schemas = loadSchemas();
+    const filterIncluded = isCSVIncluded(schemas);
+    return headers.filter(header => filterIncluded(header) && filterTermHeaders(schemas, header));
+};
+/**
+ * Convert a list of Nodes to CSV format.
+ *
+ * @param nodes List of nodes to convert.
+ * @param options Conversion options.
+ * @returns CSV content formatted for upload on Hestia.
+ */
+export const toCsv = (nodes, options) => {
+    const { includeExising, useBrackets, includeAllHeaders, selectedHeaders } = Object.assign(Object.assign({}, defaultOptions), options);
+    const headersByType = nodes.reduce((prev, _a) => {
+        var { type, '@type': _t } = _a, node = __rest(_a, ["type", '@type']);
+        type = type || _t;
+        prev[type] = type in prev ? prev[type] : [];
+        const headers = getHeaders(node, useBrackets);
+        prev[type] = Array.from(new Set([...prev[type], ...(!includeExising && isIndexedNode(headers) ? [] : headers)]));
+        return prev;
+    }, {});
+    const headers = Object.keys(headersByType).flatMap(type => headersByType[type].map(key => `${typeToColumnName(type)}.${key}`));
+    const allHeaders = selectedHeaders.length ? selectedHeaders : includeAllHeaders ? headers : filterHeaders(headers);
+    return [
+        allHeaders.join(csvColSep),
+        nodes
+            // remove all top-level nodes that have an @id - already uploaded
+            .filter(node => includeExising || !node['@id'])
+            .map(node => allHeaders
+            .map(header => {
+            const [type, ...rest] = header.split('.');
+            const ntype = node.type || node['@type'];
+            const value = typeToColumnName(ntype) === type ? get(node, rest.join('.'), noValue) : noValue;
+            return Array.isArray(value) ? escapeField(value.join(';')) : escapeField(value);
+        })
+            .join(csvColSep))
+            .join('\n')
+    ].join('\n');
+};

package/esm/default-values.js

@@ -0,0 +1,66 @@
+import { SchemaType, CycleFunctionalUnit } from '@hestia-earth/schema';
+import { ellipsis, keyToLabel, reduceUndefinedValues } from './utils';
+const findLinkedNode = (nodes, type, node) => node
+    ? nodes.find(v => (v.type === type && v.id === node.id) || (v['@type'] === type && v['@id'] === node['@id'])) || node
+    : undefined;
+export const siteLocationName = (region, country) => [
+    region === null || region === void 0 ? void 0 : region.name,
+    // make sure country doesnt appear in region already, if so don't add it
+    (country === null || country === void 0 ? void 0 : country.name) ? ((region === null || region === void 0 ? void 0 : region.name) && region.name.includes(country === null || country === void 0 ? void 0 : country.name) ? undefined : country === null || country === void 0 ? void 0 : country.name) : undefined
+]
+    .filter(Boolean)
+    .join(', ');
+export const primaryProduct = (products, defaultValue = {}) => (products && products.length
+    ? products.find(product => product.primary || product.economicValueShare > 50) || products[0]
+    : null) || defaultValue;
+const defaultName = (product, country, region, endDate, treatment, description) => [
+    (product === null || product === void 0 ? void 0 : product.name) || 'No Product',
+    siteLocationName(region, country),
+    endDate,
+    ellipsis(treatment, 20),
+    ellipsis(description, 30)
+]
+    .filter(Boolean)
+    .join(' - ');
+export const cycleDefaultName = ({ endDate, treatment, description, products }, site) => { var _a; return defaultName((_a = primaryProduct(products)) === null || _a === void 0 ? void 0 : _a.term, site === null || site === void 0 ? void 0 : site.country, site === null || site === void 0 ? void 0 : site.region, endDate, treatment, description); };
+export const defaultSiteArea = (cycle) => reduceUndefinedValues({
+    siteArea: cycle.functionalUnit === CycleFunctionalUnit['1 ha'] ? cycle.siteArea || 1 : undefined
+});
+export const extendCycle = (nodes, cycle) => (Object.assign(Object.assign(Object.assign({}, cycle), { name: cycleDefaultName(cycle, findLinkedNode(nodes, SchemaType.Site, cycle.site)) }), defaultSiteArea(cycle)));
+export const impactAssessmentDefaultName = ({ product, country, region, endDate }) => defaultName(product === null || product === void 0 ? void 0 : product.term, country, region, endDate);
+export const extendImpactAssessment = (nodes, impactAssessment) => {
+    var _a;
+    const cycle = findLinkedNode(nodes, SchemaType.Cycle, impactAssessment.cycle);
+    // replace the product if there is a single match in the Cycle products
+    const products = (_a = cycle === null || cycle === void 0 ? void 0 : cycle.products) === null || _a === void 0 ? void 0 : _a.filter(v => { var _a, _b, _c; return ((_a = v.term) === null || _a === void 0 ? void 0 : _a['@id']) === ((_c = (_b = impactAssessment === null || impactAssessment === void 0 ? void 0 : impactAssessment.product) === null || _b === void 0 ? void 0 : _b.term) === null || _c === void 0 ? void 0 : _c['@id']); });
+    const product = (products === null || products === void 0 ? void 0 : products.length) === 1 ? products[0] : impactAssessment.product;
+    return Object.assign(Object.assign(Object.assign({}, impactAssessment), { name: impactAssessment.name || impactAssessmentDefaultName(impactAssessment), source: impactAssessment.source || (cycle === null || cycle === void 0 ? void 0 : cycle.defaultSource), product }), (cycle
+        ? {
+            cycle: reduceUndefinedValues({
+                id: cycle.id,
+                type: SchemaType.Cycle,
+                name: cycle.name || cycleDefaultName(cycle, findLinkedNode(nodes, SchemaType.Site, cycle.site)),
+                description: cycle.description
+            })
+        }
+        : {}));
+};
+export const siteDefaultName = ({ siteType, region, country, description }, organisation) => [
+    siteType ? keyToLabel(siteType) : null,
+    organisation === null || organisation === void 0 ? void 0 : organisation.name,
+    siteLocationName(region, country),
+    ellipsis(description, 30)
+]
+    .filter(Boolean)
+    .join(' - ');
+export const extendSite = (nodes, site) => {
+    const org = findLinkedNode(nodes, SchemaType.Organisation, site.organisation);
+    return Object.assign(Object.assign({}, site), { name: siteDefaultName(site, org) });
+};
+const extendNodeType = {
+    [SchemaType.Cycle]: extendCycle,
+    [SchemaType.ImpactAssessment]: extendImpactAssessment,
+    [SchemaType.Site]: extendSite
+};
+const extendNode = (nodes) => (node) => node.type in extendNodeType ? reduceUndefinedValues(extendNodeType[node.type](nodes, node), true) : node;
+export const setDefaultValues = (nodes) => nodes.map(extendNode(nodes));

package/esm/index.js

@@ -0,0 +1,6 @@
+export { jsonToCsv } from './utils';
+export { toCsvPivot } from './csv-pivot';
+export { pivotNode, pivotNodes } from './json-pivot';
+export * from './csv';
+export * from './json';
+export { cycleDefaultName, extendCycle, impactAssessmentDefaultName, extendImpactAssessment, siteLocationName, defaultSiteArea, extendSite } from './default-values';

package/esm/json-pivot.js

@@ -0,0 +1,163 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { NodeType, uniquenessFields, isBlankNode, isNode, termFields, refToSchemaType } from '@hestia-earth/schema';
+import { keyType } from '@hestia-earth/json-schema/schema-utils';
+const get = require('lodash.get');
+import { childkey, findNonDuplicates, omit, parentKey } from './utils';
+const ignoreKeys = [
+    '@context',
+    '@type',
+    'type',
+    'added',
+    'addedVersion',
+    'updated',
+    'updatedVersion',
+    '_cache',
+    // ignore all term keys as only the `@id` is included in the key
+    'term',
+    ...termFields.map(v => `term.${v}`)
+];
+const headerJoin = '+';
+const headerParentKey = (key) => key.split(headerJoin)[0];
+const uniqueData = (value, key) => {
+    // in some cases, we are getting a list using "inputs.@id", but `get` will not be able to access this
+    const parentData = key.includes('.') ? get(value, parentKey(key), undefined) : undefined;
+    return Array.isArray(parentData) ? parentData.map(d => uniqueData(d, childkey(key))) : get(value, key, undefined);
+};
+const valueAsString = (value) => (Array.isArray(value) ? value : [value]).map(v => `${v}`).join(';');
+const valueAsKey = (value) => ([value.match(/[\s\"\'\.;]/g)].some(Boolean) ? `[${value}]` : value);
+const pivotValue = (schemas, nodeType, key, value) => {
+    var _a, _b;
+    // nodeType = Cycle
+    // key = emissions
+    // value = {'term':{'@id':'gwp100}, 'dates':['2021','2022'], 'value':[10,12]}
+    const uniqueFields = (_b = (_a = uniquenessFields[nodeType]) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : [];
+    // uniqueFields = ['term.@id', 'dates']
+    const pivotedKey = uniqueFields.length
+        ? uniqueFields
+            .map(field => {
+            const data = uniqueData(value, field);
+            return typeof data === 'undefined'
+                ? undefined
+                : field === 'term.@id' || uniqueFields.length === 1
+                    ? valueAsKey(valueAsString(data))
+                    : `${parentKey(field)}[${valueAsString(data)}]`;
+        })
+            .filter(Boolean)
+            .join(headerJoin)
+        : '';
+    // pivotedKey = 'gwp100+dates[2021;2022]'
+    const data = omit(pivotNode(schemas, value, false), [...uniqueFields, ...ignoreKeys]);
+    return { [pivotedKey]: data };
+};
+const simplifiedKeys = (keys) => findNonDuplicates(keys.map(headerParentKey));
+const mergeUnpivotedBlankNode = (values, existingValue) => Object.assign({}, ...values.map(v => ({ [v]: {} })), existingValue || {});
+const mergeUnpivotedNodes = (values, uniqueArrayKey) => values.map(v => ({ [uniqueArrayKey]: v }));
+const mergeUnpivotedByType = {
+    number: values => Number(values[0]),
+    string: values => values[0],
+    boolean: values => Boolean(values[0]),
+    null: () => null,
+    array: (values, definition, uniqueArrayKey, existingValue) => {
+        var _a;
+        return ((_a = definition === null || definition === void 0 ? void 0 : definition.items) === null || _a === void 0 ? void 0 : _a.$ref)
+            ? mergeUnpivotedByType.$ref(values, definition.items, uniqueArrayKey, existingValue)
+            : [...(existingValue || []), ...values]
+                .map(v => mergeUnpivotedByType[definition.items.type || 'string']([v]))
+                .join(';');
+    },
+    $ref: (values, { $ref }, uniqueArrayKey, existingValue) => isBlankNode({ type: refToSchemaType($ref) })
+        ? mergeUnpivotedBlankNode(values, existingValue)
+        : mergeUnpivotedNodes(values, uniqueArrayKey)
+};
+const mergeUnpivotedValue = (definition, uniqueArrayItem, data, nodeValue, pivotedKey) => {
+    var _a;
+    const [key, newValues] = [pivotedKey.split('[')[0], pivotedKey.split('[')[1].replace(']', '').split(';')];
+    const newValueDefinition = (_a = definition === null || definition === void 0 ? void 0 : definition.properties) === null || _a === void 0 ? void 0 : _a[key];
+    const uniqueArrayKey = childkey((uniqueArrayItem !== null && uniqueArrayItem !== void 0 ? uniqueArrayItem : []).find(v => v.startsWith(key)));
+    const valueType = newValueDefinition.type;
+    const functionValueType = '$ref' in newValueDefinition ? '$ref' : Array.isArray(valueType) ? valueType[0] : valueType;
+    data[key] = mergeUnpivotedByType[functionValueType](newValues, newValueDefinition, uniqueArrayKey, nodeValue[key]);
+    return data;
+};
+const unpivotBlankNode = (definition, uniqueArrayItem, key, value) => (Object.assign(Object.assign({}, value), key
+    .split(headerJoin)
+    .slice(1)
+    .reduce((prev, curr) => mergeUnpivotedValue(definition, uniqueArrayItem, prev, value, curr), {})));
+/**
+ * Pivot list of Blank Node and simplify when only one instance is found
+ *
+ * @param nodeType
+ * @param key
+ * @param value
+ */
+const pivotBlankNodes = (schemas, nodeType, key, value) => {
+    var _a, _b;
+    const uniqueFields = (_b = (_a = uniquenessFields[nodeType]) === null || _a === void 0 ? void 0 : _a[key]) !== null && _b !== void 0 ? _b : [];
+    const data = Object.assign({}, ...value.map(val => pivotValue(schemas, nodeType, key, val)));
+    const dataKeys = Object.keys(data);
+    const uniqueKeys = simplifiedKeys(dataKeys);
+    return (uniqueFields === null || uniqueFields === void 0 ? void 0 : uniqueFields[0]) === 'term.@id'
+        ? Object.fromEntries(Object.entries(data).map(([entryKey, value]) => {
+            var _a, _b, _c, _d;
+            const isUnique = entryKey !== headerParentKey(entryKey) && uniqueKeys.includes(headerParentKey(entryKey));
+            const blankNodeType = keyType(schemas[nodeType], key);
+            return [
+                isUnique ? headerParentKey(entryKey) : entryKey,
+                isUnique
+                    ? unpivotBlankNode(schemas[blankNodeType], (_d = (_c = (_b = (_a = schemas[nodeType]) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b[key]) === null || _c === void 0 ? void 0 : _c.uniqueArrayItem) !== null && _d !== void 0 ? _d : [], entryKey, value)
+                    : value
+            ];
+        }))
+        : data;
+};
+/**
+ * Pivot node and return in compacted format.
+ *
+ * @param schemas The definitions of the HESTIA Schema (`import { loadSchemas } from "@hestia-earth/json-schema"`)
+ * @param node The node to pivot.
+ * @param keepType To keep the `@type`/`type` key in the pivoted format.
+ * @returns
+ */
+export const pivotNode = (schemas, _a, keepType) => {
+    var { '@type': _type, type } = _a, node = __rest(_a, ['@type', "type"]);
+    if (keepType === void 0) { keepType = true; }
+    return Object.fromEntries([
+        keepType && (_type || type) ? [_type ? '@type' : 'type', _type || type] : null,
+        ...Object.entries(node)
+            .filter(([key]) => !ignoreKeys.includes(key) && ((_type || type) !== NodeType.Term || !termFields.includes(key)))
+            .map(([key, value]) => [
+            key,
+            value === null
+                ? null
+                : typeof value === 'object'
+                    ? Array.isArray(value)
+                        ? value.every(isNode)
+                            ? value.map(v => pivotNode(schemas, v, false))
+                            : value.every(isBlankNode)
+                                ? pivotBlankNodes(schemas, _type || type, key, value)
+                                : valueAsString(value)
+                        : pivotNode(schemas, value, false) // deep pivoting
+                    : valueAsString(value)
+        ])
+    ].filter(Boolean));
+};
+export const pivotNodes = (schemas, nodes) => {
+    return nodes.map(node => {
+        try {
+            return pivotNode(schemas, node);
+        }
+        catch (err) {
+            throw new Error(`Error pivoting ${node['@type'] || node.type} with id "${node['@id'] || node.id}":\n${err.toString()}`);
+        }
+    });
+};

package/esm/json.js

@@ -0,0 +1,451 @@
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as csvtojson from 'csvtojson';
+import * as levenshtein from 'fast-levenshtein';
+import { wktToGeoJSON } from '@terraformer/wkt';
+import { NodeType, typeToSchemaType, refToSchemaType, SchemaType, isBlankNode, isTypeNode } from '@hestia-earth/schema';
+import { defaultProperties, excludedDefaultProperties } from '@hestia-earth/json-schema/types';
+import { nonEmptyValue, reduceUndefinedValues, isEmpty, isIri, isBoolean, isNumber } from './utils';
+import { setDefaultValues } from './default-values';
+export const acceptedNodeTypes = Object.values(NodeType);
+export var ErrorKeys;
+(function (ErrorKeys) {
+    ErrorKeys["SchemaNotFound"] = "schema-not-found";
+    ErrorKeys["PropertyNotFound"] = "property-not-found";
+    ErrorKeys["PropertyInvalidFormat"] = "property-invalid-format";
+    ErrorKeys["DuplicatedIdFields"] = "duplicated-id-fields";
+    ErrorKeys["ObjectArrayInvalid"] = "object-array-invalid";
+})(ErrorKeys || (ErrorKeys = {}));
+const IGNORE_FIELD_KEY = '-';
+const VALUE_TYPE_KEY = 'valueType';
+const DEFAULT_ARRAY_DELIMITER = ';';
+const arrayDelimiter = () => {
+    try {
+        return process.env.CSV_ARRAY_DELIMITER || DEFAULT_ARRAY_DELIMITER;
+    }
+    catch (err) {
+        return DEFAULT_ARRAY_DELIMITER;
+    }
+};
+const safeParseJSON = (obj) => {
+    // throw already handled error or throw a generic invalid-format error
+    let data;
+    try {
+        data = JSON.parse(obj);
+    }
+    catch (err) { }
+    return data;
+};
+const internalProperties = ({ properties }) => Object.keys(properties).filter(property => properties[property].internal);
+const isEmptyCell = (value) => value === IGNORE_FIELD_KEY || value === '';
+const nonEmptyCell = (value) => !isEmptyCell(value);
+const isEmptyNode = (node, schemas) => {
+    const type = node.type || node['@type'];
+    const schema = type ? schemas[type] : null;
+    const properties = Object.keys(node).filter(key => !excludedDefaultProperties.includes(key));
+    const defaultProperties = schema ? getDefaultProperties(schema).map(({ property }) => property) : [];
+    // get the list of properties that do not have a default value
+    const nonDefaultProperties = properties.filter(p => !defaultProperties.includes(p));
+    return nonDefaultProperties.length === 0;
+};
+const isEmptyValueType = {
+    undefined: () => true,
+    number: (value) => isNaN(value),
+    [SchemaType.Term]: (value) => !(value['@id'] || value.id || value.name),
+    blankNode: isEmptyNode,
+    array: (value) => value.filter(v => !isEmpty(v)).length === 0,
+    object: (value, schemas) => value === null
+        ? false
+        : Array.isArray(value)
+            ? isEmptyValueType.array(value)
+            : (value['@type'] || value.type) === SchemaType.Term
+                ? isEmptyValueType[SchemaType.Term](value)
+                : isBlankNode(value)
+                    ? isEmptyValueType.blankNode(value, schemas)
+                    : Object.keys(value).length === 0
+};
+const isEmptyValue = (value, schemas) => typeof value in isEmptyValueType ? isEmptyValueType[typeof value](value, schemas) : isEmptyCell(value);
+const compileFullKey = (key1, key2) => {
+    // handle arrays
+    const joinKey = (key2 || '').startsWith('[') ? '' : '.';
+    return [key1, key2].filter(Boolean).join(joinKey);
+};
+const propertyRequiredValue = (value, required) => {
+    const val = typeof value === 'object' && required[0] in value ? value[required[0]] : value;
+    return nonEmptyCell(val) ? { [required[0]]: val } : {};
+};
+const parseErrors = (err) => { var _a; return ((_a = safeParseJSON(err.message)) === null || _a === void 0 ? void 0 : _a.errors) || []; };
+const throwError = (error) => {
+    throw new Error(error);
+};
+export const throwCSVErrors = (errors) => throwError(JSON.stringify({ errors }));
+const schemaNotFoundError = (schema) => throwCSVErrors([
+    {
+        message: ErrorKeys.SchemaNotFound,
+        schema
+    }
+]);
+const computeSuggestions = ({ title, properties }, key) => {
+    const internal = internalProperties({ properties });
+    const allKeys = Object.keys(properties).filter(k => ![...excludedDefaultProperties, ...internal].includes(k));
+    return [title === SchemaType.Term].every(Boolean)
+        ? ['@id', 'name']
+        : allKeys.filter(v => levenshtein.get(v, key) <= 3);
+};
+const propertyNotFoundError = (schema, key, value) => throwCSVErrors([
+    {
+        schema: schema.title,
+        message: ErrorKeys.PropertyNotFound,
+        schemaKey: key,
+        key,
+        value,
+        suggestions: computeSuggestions(schema, key)
+    }
+]);
+const propertyInvalidFormat = (schema, key, value, func) => {
+    try {
+        return func();
+    }
+    catch (err) {
+        const errors = parseErrors(err);
+        // throw already handled error or throw a generic invalid-format error
+        return throwCSVErrors(errors.length
+            ? errors.map(data => (Object.assign(Object.assign({}, data), { key: compileFullKey(key, data.key) })))
+            : [
+                {
+                    schema: schema.title,
+                    message: ErrorKeys.PropertyInvalidFormat,
+                    schemaKey: key,
+                    key,
+                    value,
+                    error: err === null || err === void 0 ? void 0 : err.message
+                }
+            ]);
+    }
+};
+const validateDuplicatedIdFields = (schema, key, value) => typeof value === 'object' && [value.id, value['@id']].every(v => !!v && nonEmptyCell(v))
+    ? throwCSVErrors([
+        {
+            schema: schema.title,
+            message: ErrorKeys.DuplicatedIdFields,
+            schemaKey: key,
+            key,
+            value
+        }
+    ])
+    : null;
+const handleArrayError = func => (value, index) => {
+    try {
+        return func(value, index);
+    }
+    catch (err) {
+        const errors = parseErrors(err);
+        // throw already handled error or throw a generic invalid-format error
+        return errors.length
+            ? throwCSVErrors(errors.map(data => (Object.assign(Object.assign({}, data), { key: compileFullKey(`${index}`, data.key) }))))
+            : (() => {
+                throw err;
+            })();
+    }
+};
+const allowedGeoJSONTypes = ['FeatureCollection', 'Feature', 'GeometryCollection'];
+const geoJSONGeomtryTypeValidation = {
+    Point: () => throwError('use "latitude" and "longitude" instead of "Point"'),
+    MultiPoint: () => throwError('use a "Polygon" instead of "MultiPoint"'),
+    LineString: () => throwError('use a "Polygon" instead of "LineString"'),
+    MultiLineString: () => throwError('use a "MultiPolygon" instead of "MultiLineString"')
+};
+const validateGeoJSONGeometryType = ({ type }) => type in geoJSONGeomtryTypeValidation ? geoJSONGeomtryTypeValidation[type]() : true;
+/**
+ * Validate the GeoJSON format provided.
+ * GeoJSON is only relevant if it includes a `Polygon` or `MultiPolygon`, which would represent an area.
+ * If a single `Point` is provided, `latitude` and `longitude` should be used instead.
+ *
+ * @param value The GeoJSON as object.
+ */
+const validateGeoJSONFormat = (value) => (!allowedGeoJSONTypes.includes(value.type)
+    ? throwError(`Invalid GeoJSON "type". Allowed values are: ${allowedGeoJSONTypes.join(', ')}`)
+    : 'geometries' in value
+        ? !value.geometries.length
+            ? throwError('This GeoJSON appears to be empty. Please either add coordinates or remove the field.')
+            : (value.geometries || []).every(validateGeoJSONGeometryType)
+        : 'geometry' in value
+            ? validateGeoJSONGeometryType(value.geometry)
+            : 'features' in value
+                ? !value.features.length
+                    ? throwError('This GeoJSON appears to be empty. Please either add coordinates or remove the field.')
+                    : (value.features || []).every(validateGeoJSONFormat)
+                : true)
+    ? value
+    : null;
+const parseWtkValue = (value) => {
+    try {
+        return {
+            type: 'FeatureCollection',
+            features: [
+                {
+                    type: 'Feature',
+                    properties: {},
+                    geometry: wktToGeoJSON(value)
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return null;
+    }
+};
+const parseJsonValue = (value) => {
+    try {
+        const data = JSON.parse(value);
+        return ['Polygon', 'MultiPolygon'].includes(data.type)
+            ? {
+                type: 'FeatureCollection',
+                features: [
+                    {
+                        type: 'Feature',
+                        properties: {},
+                        geometry: data
+                    }
+                ]
+            }
+            : ['Feature'].includes(data.type)
+                ? {
+                    type: 'FeatureCollection',
+                    features: [
+                        Object.assign(Object.assign({}, data), { properties: {} // make sure they are set or it is invalid
+                         })
+                    ]
+                }
+                : data;
+    }
+    catch (error) {
+        return throwError('Unable to parse GeoJSON value. Please make sure the formatting is correct.');
+    }
+};
+const parseGeoJSONValue = (value) => {
+    const result = parseWtkValue(value) || parseJsonValue(value);
+    return result ? validateGeoJSONFormat(result) : value;
+};
+/**
+ * If the user provided a non-object where an object was expected, assume it was meant to be the `name` property.
+ * For Blank Nodes, we assume it is the `term.name`.
+ * For non-Term Nodes, we assume it is the `id`.
+ *
+ * @param value The value mapped as a Ref
+ */
+const schemaRefValue = (value, type) => typeof value === 'object'
+    ? value
+    : type === SchemaType.Term
+        ? { name: value }
+        : isBlankNode({ type })
+            ? { term: { name: value } }
+            : { id: value };
+const isSemver = (value) => value.match(/^[\d]+\.[\d]+\.[\d]+$/) !== null;
+export const cleanStringValue = (value) => (isNumber(value) && !isSemver(value) ? value.replace(/\.0$/, '') : value).trim();
+const propertyTypeToValue = {
+    null: (value, ...args) => (isEmptyCell(value) ? null : propertyTypeToValue.auto(value, ...args)),
+    string: (value) => cleanStringValue(value || ''),
+    number: (value) => isEmptyCell(value)
+        ? undefined
+        : isNaN(+value)
+            ? (() => {
+                throw new Error('failed to parse number');
+            })()
+            : +value,
+    integer: (value) => (isEmptyCell(value) ? undefined : +value),
+    boolean: (value) => isEmptyCell(value)
+        ? undefined
+        : isBoolean(value)
+            ? value.toLowerCase() === 'true'
+            : isNumber(value)
+                ? +value === 1 // handle setting 1 or 1.0 as true
+                : (() => {
+                    throw new Error('failed to parse boolean, expected true or false');
+                })(),
+    object: (value, schemas, { $ref, required, geojson }, params) => geojson
+        ? propertyTypeToValue.geojson(value)
+        : $ref
+            ? propertyTypeToValue.$ref(value, schemas, { $ref }, params)
+            : propertyTypeToValue.required(value, schemas, { required }, params),
+    array: (value, schemas, { items }, params) => (Array.isArray(value) ? value : value.split(arrayDelimiter()))
+        .map(handleArrayError(val => items
+        ? '$ref' in items
+            ? propertyTypeToValue.object(val, schemas, items, params)
+            : Array.isArray(items.type) || items.anyOf
+                ? val === IGNORE_FIELD_KEY
+                    ? null
+                    : propertyTypeToValue.auto(val, schemas, items, params)
+                : propertyTypeToValue[items.type](val, schemas, items, params)
+        : val))
+        .filter(val => !isEmptyValue(val, schemas)),
+    // try to determine the type automatically
+    auto: (value, schemas, _d, params) => 
+    // iris are mapped as {@id: val}
+    isIri(value)
+        ? propertyTypeToValue.required(value, schemas, { required: ['@id'] }, params)
+        : isBoolean(value)
+            ? propertyTypeToValue.boolean(value)
+            : isNumber(value)
+                ? propertyTypeToValue.number(value)
+                : value === 'null'
+                    ? null
+                    : propertyTypeToValue.string(value),
+    required: (value, _schemas, { required }) => {
+        const data = propertyRequiredValue(value, required);
+        return isEmpty(data) ? {} : data;
+    },
+    $ref: (value, schemas, { $ref }, params) => {
+        const schemaType = refToSchemaType($ref);
+        const schema = schemaType ? schemas[schemaType] : undefined;
+        const data = schema
+            ? mapContent(schemas, schema, params)(schemaRefValue(value, schemaType))
+            : $ref in propertyTypeToValue
+                ? propertyTypeToValue[$ref](value)
+                : safeParseJSON(value);
+        const addDefaults = isBlankNode(data) || schemaType === SchemaType.Actor; // only blank nodes or actors allowed
+        return isEmpty(data)
+            ? {}
+            : !!schema
+                ? extendDataFromSchema(data, schema, schemaType, Object.assign(Object.assign({}, params), { addDefaults }))
+                : data;
+    },
+    geojson: value => (isEmptyCell(value) ? undefined : parseGeoJSONValue(value))
+};
+const getPropertyDefinition = (schema, key, ignoreErrors = false, value) => key in schema.properties ? schema.properties[key] : !ignoreErrors && propertyNotFoundError(schema, key, value);
+const getValueType = (schema, json) => VALUE_TYPE_KEY in schema.properties
+    ? // valueType can be present but skipped
+        (json[VALUE_TYPE_KEY] !== IGNORE_FIELD_KEY ? json[VALUE_TYPE_KEY] : null) ||
+            schema.properties[VALUE_TYPE_KEY].default
+    : null;
+const getPropertyType = (def, key, valueType) => 
+// default type is object (like $ref)
+(key === 'value' && valueType
+    ? valueType
+    : Array.isArray(def.type)
+        ? def.type.includes('null')
+            ? 'null'
+            : 'auto'
+        : def.type) || 'object';
+const setDefaultProperty = (prop, def, node, ignoreInternal = false) => prop !== VALUE_TYPE_KEY &&
+    // only get default if internal or not present
+    ((!ignoreInternal && def.internal) || !node || !(prop in node));
+const getDefaultProperties = (schema, node, ignoreInternal = false) => defaultProperties(schema)
+    .map((property) => {
+    const def = schema.properties[property];
+    return setDefaultProperty(property, def, node, ignoreInternal) ? { property, defaultValue: def.default } : null;
+}, {})
+    .filter(Boolean);
+const filterProperties = (data, excludedProps) => Object.keys(data)
+    .filter(key => !excludedProps.includes(key))
+    .reduce((prev, curr) => (Object.assign(Object.assign({}, prev), { [curr]: data[curr] })), {});
+const nodeType = (id, type, existingNode = false) => type
+    ? existingNode
+        ? isTypeNode(type)
+            ? { '@type': type, '@id': id }
+            : { '@type': type }
+        : isTypeNode(type)
+            ? { type, id }
+            : { type }
+    : {};
+const extendDataFromSchema = (_a, schema, type, _b) => {
+    var { id, '@id': _id, type: _t } = _a, data = __rest(_a, ["id", '@id', "type"]);
+    var _c = _b === void 0 ? {} : _b, ignoreInternal = _c.ignoreInternal, addDefaults = _c.addDefaults, convertToExistingNodes = _c.convertToExistingNodes;
+    return reduceUndefinedValues(Object.assign(Object.assign(Object.assign({}, filterProperties(data, ignoreInternal ? [] : internalProperties(schema))), (addDefaults && !_id && schema
+        ? getDefaultProperties(schema, data, ignoreInternal).reduce((prev, { property, defaultValue }) => {
+            prev[property] = defaultValue;
+            return prev;
+        }, {})
+        : {})), nodeType(id || _id, type, !!_id || convertToExistingNodes)), true);
+};
+const validateArrayType = (schema, def, key, value) => typeof value !== 'object' ||
+    def.type !== 'array' ||
+    Array.isArray(value) ||
+    throwCSVErrors([
+        {
+            schema: schema.title,
+            message: ErrorKeys.ObjectArrayInvalid,
+            schemaKey: key,
+            key,
+            value
+        }
+    ]);
+const mapContent = (schemas, schema, params) => (json) => {
+    const values = Object.keys(json)
+        .filter(nonEmptyCell)
+        .map(key => {
+        try {
+            const value = json[key];
+            // make sure we are not using both `id` and `@id` fields
+            validateDuplicatedIdFields(schema, key, value);
+            const propertyDefinition = getPropertyDefinition(schema, key, false, json);
+            const valueType = getValueType(schema, json);
+            const type = getPropertyType(propertyDefinition, key, valueType);
+            validateArrayType(schema, propertyDefinition, key, value);
+            const newValue = key === VALUE_TYPE_KEY
+                ? ''
+                : propertyInvalidFormat(schema, key, value, () => Array.isArray(type) ? value : propertyTypeToValue[type](value, schemas, propertyDefinition, params));
+            return {
+                errors: [],
+                value: type !== 'null' && isEmptyValue(newValue, schemas) ? undefined : [key, newValue]
+            };
+        }
+        catch (err) {
+            const { errors } = JSON.parse(err.message);
+            return { errors };
+        }
+    });
+    const errors = values.filter(({ errors }) => (errors === null || errors === void 0 ? void 0 : errors.length) > 0).flatMap(({ errors }) => errors);
+    return (errors === null || errors === void 0 ? void 0 : errors.length)
+        ? throwError(JSON.stringify({ errors }))
+        : Object.fromEntries([schema.$id ? ['type', schema.title] : null, ...values.map(({ value }) => value)].filter(Boolean));
+};
+export const formatNode = (schemas, type, data, params = {}) => {
+    const schema = type in schemas && acceptedNodeTypes.includes(type) ? schemas[type] : schemaNotFoundError(type);
+    const content = mapContent(schemas, schema, params)(data);
+    return reduceUndefinedValues(extendDataFromSchema(content, schema, type, params), true);
+};
+export const filterEmptyNode = (schemas, node) => {
+    const type = node.type || node['@type'];
+    const schema = type ? schemas[type] : null;
+    // make sure defaultProperties are not counted
+    return !!schema && !isEmptyNode(node, schemas);
+};
+const convetToNode = (schemas, params) => (data) => Object.keys(data)
+    .filter(nonEmptyValue)
+    .map(type => formatNode(schemas, typeToSchemaType(type) || type, data[type], Object.assign(Object.assign({}, params), { convertToExistingNodes: params.convertToExistingNodes || (typeof data[type] === 'object' ? '@id' in data[type] : false) })))
+    .filter(node => filterEmptyNode(schemas, node));
+/**
+ * Convert CSV to HESTIA JSON-LD format.
+ *
+ * @param schemas The definitions of the HESTIA Schema (`import { loadSchemas } from "@hestia-earth/json-schema"`)
+ * @param content The content of the CSV as a string
+ * @param params Conversion parameters.
+ * @returns A list of JSON-LD content.
+ */
+export const toJson = (schemas, content, params = { ignoreInternal: true, addDefaults: true }) => __awaiter(void 0, void 0, void 0, function* () {
+    const nodes = yield csvtojson({
+        delimiter: 'auto',
+        ignoreColumns: /^$/
+    }).fromString(content);
+    const converted = nodes.flatMap(convetToNode(schemas, params));
+    return setDefaultValues(converted);
+});

package/esm/utils.js

@@ -0,0 +1,92 @@
+import { json2csv } from 'json-2-csv';
+const get = require('lodash.get');
+const unset = require('lodash.unset');
+export const omitKeys = [
+    '@context',
+    'schemaVersion',
+    'dataPrivate',
+    ...['bibliography', 'site', 'cycle', 'impactAssessment', 'defaultSource', 'source'].flatMap(k => [
+        `${k}.type`,
+        `${k}.@type`
+    ])
+];
+export const parentKey = (key) => key.split('.')[0];
+export const childkey = (key) => key.split('.').slice(1).join('.');
+export const omit = (data, keys) => {
+    const obj = Object.assign({}, data);
+    keys.forEach(key => {
+        unset(obj, key);
+        // handle arrays and notation without array
+        const _parentKey = parentKey(key);
+        const _childkey = childkey(key);
+        const parentData = key.includes('.') ? get(obj, _parentKey, undefined) : undefined;
+        if (typeof parentData === 'object') {
+            if (Array.isArray(parentData)) {
+                parentData.forEach((_v, index) => {
+                    unset(obj, `${_parentKey}[${index}].${_childkey}`);
+                });
+                // only keep values that are not empty
+                obj[_parentKey] = obj[_parentKey].filter(v => !isEmpty(v));
+            }
+            if (isEmpty(obj[_parentKey])) {
+                unset(obj, _parentKey);
+            }
+        }
+    });
+    return obj;
+};
+export const isExpandable = (val) => !!val && typeof val === 'object' && (Array.isArray(val) ? val.every(isExpandable) : Object.keys(val).length);
+export const isIri = (value) => (value || '').startsWith('http');
+export const isBoolean = (value) => value.toLowerCase() === 'true' || value.toLowerCase() === 'false';
+export const isNumber = (n) => !isNaN(parseFloat(`${n}`)) && isFinite(parseFloat(`${n}`));
+const ignoreKey = (key) => !['@type', 'type'].includes(key);
+export const isEmpty = (value, minKeys = 1) => value === null ||
+    typeof value === 'undefined' ||
+    (typeof value === 'object'
+        ? Array.isArray(value)
+            ? !value.length
+            : Object.keys(value).filter(key => key !== 'type').length < minKeys
+        : value === '');
+export const nonEmptyValue = (value) => !isEmpty(value) && value !== '-';
+export const nonEmptyNode = (node) => typeof node === 'object'
+    ? Object.keys(node).filter(key => ignoreKey(key) && !isEmpty(node[key])).length > 0
+    : nonEmptyValue(node);
+const isUndefined = (value, allowNull) => (value === null && !allowNull) ||
+    typeof value === 'undefined' ||
+    (typeof value === 'object' && value !== null && !(value instanceof Date) && !Object.keys(value).length);
+export const reduceUndefinedValues = (obj, allowNull = false) => Object.keys(obj).reduce((prev, key) => {
+    const value = obj[key];
+    return Object.assign(Object.assign({}, prev), (isUndefined(value, allowNull) ? {} : { [key]: value }));
+}, {});
+export const ellipsis = (text = '', maxlength = 20) => text.length > maxlength ? `${text.substring(0, maxlength)}...` : text;
+export const keyToLabel = (key) => `${key[0].toUpperCase()}${key
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([_])([a-zA-Z])/g, g => ` ${g[1].toUpperCase()}`)
+    .substring(1)}`;
+export const diffInDays = (date1, date2) => Math.abs(Math.round((new Date(date2).getTime() - new Date(date1).getTime()) / (24 * 60 * 60 * 1000)));
+export const daysBefore = (date = new Date(), days = 1) => {
+    const newDate = new Date(date);
+    newDate.setDate(newDate.getDate() - days);
+    return newDate;
+};
+export const daysInYear = (year) => ((year % 4 === 0 && year % 100 > 0) || year % 400 === 0 ? 366 : 365);
+export const convertValue = (value) => Array.isArray(value) ? value.map(String).join(';') : typeof value === 'object' ? JSON.stringify(value) : value;
+const count = (values) => values.reduce((a, b) => (Object.assign(Object.assign({}, a), { [b]: (a[b] || 0) + 1 })), {});
+const duplicates = (dict) => Object.keys(dict).filter(a => dict[a] > 1);
+const nonDuplicates = (dict) => Object.keys(dict).filter(a => dict[a] === 1);
+export const findDuplicates = (values) => duplicates(count(values));
+export const findNonDuplicates = (values) => nonDuplicates(count(values));
+export const uncapitalize = (text) => `${text[0].toLowerCase()}${text.substring(1)}`;
+/**
+ * Move every item on the same row.
+ *
+ * @param data
+ * @returns List of original records with less gaps in data.
+ */
+const compactDataForCsv = (data) => data.reduce((prev, curr) => {
+    const [[key, value]] = Object.entries(curr);
+    const prevNoKeyIndex = prev.findIndex(p => !Object.keys(p).includes(key));
+    prevNoKeyIndex >= 0 ? (prev[prevNoKeyIndex][key] = value) : prev.push(curr);
+    return prev;
+}, []);
+export const jsonToCsv = (values, options = {}) => json2csv(compactDataForCsv(values), Object.assign({ emptyFieldValue: '', expandNestedObjects: true, expandArrayObjects: true, arrayIndexesAsKeys: true, sortHeader: true }, options));

package/index.d.ts

@@ -3,3 +3,4 @@ export { toCsvPivot } from './csv-pivot';
 export { pivotNode, pivotNodes } from './json-pivot';
 export * from './csv';
 export * from './json';
+export { cycleDefaultName, extendCycle, impactAssessmentDefaultName, extendImpactAssessment, siteLocationName, defaultSiteArea, extendSite } from './default-values';

package/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pivotNodes = exports.pivotNode = exports.toCsvPivot = exports.jsonToCsv = void 0;
+exports.extendSite = exports.defaultSiteArea = exports.siteLocationName = exports.extendImpactAssessment = exports.impactAssessmentDefaultName = exports.extendCycle = exports.cycleDefaultName = exports.pivotNodes = exports.pivotNode = exports.toCsvPivot = exports.jsonToCsv = void 0;
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "jsonToCsv", { enumerable: true, get: function () { return utils_1.jsonToCsv; } });
 var csv_pivot_1 = require("./csv-pivot");
@@ -24,3 +24,11 @@ Object.defineProperty(exports, "pivotNode", { enumerable: true, get: function ()
 Object.defineProperty(exports, "pivotNodes", { enumerable: true, get: function () { return json_pivot_1.pivotNodes; } });
 __exportStar(require("./csv"), exports);
 __exportStar(require("./json"), exports);
+var default_values_1 = require("./default-values");
+Object.defineProperty(exports, "cycleDefaultName", { enumerable: true, get: function () { return default_values_1.cycleDefaultName; } });
+Object.defineProperty(exports, "extendCycle", { enumerable: true, get: function () { return default_values_1.extendCycle; } });
+Object.defineProperty(exports, "impactAssessmentDefaultName", { enumerable: true, get: function () { return default_values_1.impactAssessmentDefaultName; } });
+Object.defineProperty(exports, "extendImpactAssessment", { enumerable: true, get: function () { return default_values_1.extendImpactAssessment; } });
+Object.defineProperty(exports, "siteLocationName", { enumerable: true, get: function () { return default_values_1.siteLocationName; } });
+Object.defineProperty(exports, "defaultSiteArea", { enumerable: true, get: function () { return default_values_1.defaultSiteArea; } });
+Object.defineProperty(exports, "extendSite", { enumerable: true, get: function () { return default_values_1.extendSite; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/schema-convert",
-  "version": "37.0.0",
+  "version": "37.2.0",
   "description": "HESTIA Schema Converters",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -35,5 +35,53 @@
     "json-2-csv": "^5.4.0",
     "lodash.get": "^4.0.0",
     "lodash.unset": "^4.0.0"
+  },
+  "sideEffects": false,
+  "module": "esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./convert-csv": {
+      "import": "./esm/convert-csv.js",
+      "require": "./convert-csv.js"
+    },
+    "./convert-json": {
+      "import": "./esm/convert-json.js",
+      "require": "./convert-json.js"
+    },
+    "./csv-pivot": {
+      "import": "./esm/csv-pivot.js",
+      "require": "./csv-pivot.js"
+    },
+    "./csv": {
+      "import": "./esm/csv.js",
+      "require": "./csv.js"
+    },
+    "./default-values": {
+      "import": "./esm/default-values.js",
+      "require": "./default-values.js"
+    },
+    "./file-utils": {
+      "import": "./esm/file-utils.js",
+      "require": "./file-utils.js"
+    },
+    "./json-pivot": {
+      "import": "./esm/json-pivot.js",
+      "require": "./json-pivot.js"
+    },
+    "./json": {
+      "import": "./esm/json.js",
+      "require": "./json.js"
+    },
+    "./pivot-file": {
+      "import": "./esm/pivot-file.js",
+      "require": "./pivot-file.js"
+    },
+    "./utils": {
+      "import": "./esm/utils.js",
+      "require": "./utils.js"
+    }
   }
 }