@hestia-earth/schema-convert 9.2.0 → 9.5.0

package/json.js

@@ -82,6 +82,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.toJson = exports.filterEmptyNode = exports.formatNode = exports.cleanStringValue = exports.throwCSVError = void 0;
 var csvtojson = require("csvtojson");
 var levenshtein = require("fast-levenshtein");
+var wkt_1 = require("@terraformer/wkt");
 var schema_1 = require("@hestia-earth/schema");
 var types_1 = require("@hestia-earth/json-schema/types");
 var utils_1 = require("./utils");
@@ -121,13 +122,15 @@ var isEmptyValueType = (_a = {
     },
     _a.array = function (value) { return value.filter(function (v) { return !utils_1.isEmpty(v); }).length === 0; },
     _a.object = function (value, schemas) {
-        return Array.isArray(value) ?
-            isEmptyValueType.array(value) :
-            (value['@type'] || value.type) === schema_1.SchemaType.Term ?
-                isEmptyValueType[schema_1.SchemaType.Term](value) :
-                schema_1.isBlankNode(value) ?
-                    isEmptyValueType.BlankNode(value, schemas) :
-                    Object.keys(value).length === 0;
+        return value === null
+            ? false
+            : Array.isArray(value)
+                ? isEmptyValueType.array(value)
+                : (value['@type'] || value.type) === schema_1.SchemaType.Term
+                    ? isEmptyValueType[schema_1.SchemaType.Term](value)
+                    : schema_1.isBlankNode(value)
+                        ? isEmptyValueType.BlankNode(value, schemas)
+                        : Object.keys(value).length === 0;
     },
     _a);
 var isEmptyValue = function (value, schemas) {
@@ -149,9 +152,10 @@ var propertyRequiredValue = function (value, required) {
     return nonEmptyCell(val) ? (_a = {}, _a[required[0]] = val, _a) : {};
 };
 var parseError = function (err) { return safeParseJSON(err.message); };
-exports.throwCSVError = function (error) {
-    throw new Error(JSON.stringify(error));
+var throwError = function (error) {
+    throw new Error(error);
 };
+exports.throwCSVError = function (error) { return throwError(JSON.stringify(error)); };
 var schemaNotFoundError = function (schema) { return exports.throwCSVError({
     message: 'schema-not-found',
     schema: schema
@@ -203,6 +207,41 @@ var handleArrayError = function (func) { return function (value, index) {
             })();
     }
 }; };
+var allowedGeoJSONTypes = [
+    'FeatureCollection',
+    'Feature',
+    'GeometryCollection'
+];
+var geoJSONGeomtryTypeValidation = {
+    Point: function () { return throwError('use "latitude" and "longitude" instead of "Point"'); },
+    MultiPoint: function () { return throwError('use a "Polygon" instead of "MultiPoint"'); },
+    LineString: function () { return throwError('use a "Polygon" instead of "LineString"'); },
+    MultiLineString: function () { return throwError('use a "MultiPolygon" instead of "MultiLineString"'); }
+};
+var validateGeoJSONGeometryType = function (_a) {
+    var type = _a.type;
+    return 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.
+ */
+var validateGeoJSONFormat = function (value) {
+    return (!allowedGeoJSONTypes.includes(value.type)
+        ? throwError("Invalid GeoJSON \"type\". Allowed values are: " + allowedGeoJSONTypes.join(', '))
+        : 'geometries' in value
+            ? (value.geometries || []).every(validateGeoJSONGeometryType)
+            : 'geometry' in value
+                ? validateGeoJSONGeometryType(value.geometry)
+                : 'features' in value
+                    ? (value.features || []).every(validateGeoJSONFormat)
+                    : true)
+        ? value
+        : null;
+};
 /**
  * If the user provided a non-object where an object was expected, assume it was meant to be the `name` property.
  * For non-Terms, we assume it is the `id`.
@@ -223,11 +262,13 @@ var propertyTypeToValue = {
     },
     string: function (value) { return exports.cleanStringValue(value || ''); },
     number: function (value) {
-        return isEmptyCell(value) ?
-            undefined :
-            isNaN(+value) ? (function () {
-                throw new Error('failed to parse number');
-            })() : +value;
+        return isEmptyCell(value)
+            ? undefined
+            : isNaN(+value)
+                ? (function () {
+                    throw new Error('failed to parse number');
+                })()
+                : +value;
     },
     integer: function (value) { return isEmptyCell(value) ? undefined : +value; },
     boolean: function (value) {
@@ -260,8 +301,15 @@ var propertyTypeToValue = {
     // try to determine the type automatically
     auto: function (value, schemas, _d, _i) {
         // iris are mapped as {@id: val}
-        return utils_1.isIri(value) ? propertyTypeToValue.required(value, schemas, { required: ['@id'] }, _i) : (utils_1.isBoolean(value) ? propertyTypeToValue.boolean(value) : (utils_1.isNumber(value) ? propertyTypeToValue.number(value) :
-            propertyTypeToValue.string(value)));
+        return utils_1.isIri(value)
+            ? propertyTypeToValue.required(value, schemas, { required: ['@id'] }, _i)
+            : utils_1.isBoolean(value)
+                ? propertyTypeToValue.boolean(value)
+                : utils_1.isNumber(value)
+                    ? propertyTypeToValue.number(value)
+                    : value === 'null'
+                        ? null
+                        : propertyTypeToValue.string(value);
     },
     required: function (value, _schemas, _a) {
         var required = _a.required;
@@ -272,9 +320,39 @@ var propertyTypeToValue = {
         var $ref = _a.$ref;
         var schemaType = schema_1.refToSchemaType($ref);
         var schema = schemaType ? schemas[schemaType] : undefined;
-        var data = schema ? mapContent(schemas, schema, _i)(schemaRefValue(value, schemaType)) : safeParseJSON(value);
+        var data = schema
+            ? mapContent(schemas, schema, _i)(schemaRefValue(value, schemaType))
+            : $ref in propertyTypeToValue
+                ? propertyTypeToValue[$ref](value)
+                : safeParseJSON(value);
         var includeDefaults = [schema_1.SchemaType.Actor].includes(schemaType); // only nested node allowed
-        return utils_1.isEmpty(data) ? {} : (schema ? extendDataFromSchema(data, schema, schemaType, _i, includeDefaults) : data);
+        return utils_1.isEmpty(data)
+            ? {}
+            : schema
+                ? extendDataFromSchema(data, schema, schemaType, _i, includeDefaults)
+                : data;
+    },
+    'http://json.schemastore.org/geojson': function (value) {
+        var result;
+        try {
+            result = {
+                type: 'Feature',
+                geometry: wkt_1.wktToGeoJSON(value)
+            };
+        }
+        catch (e1) {
+            try {
+                var data = JSON.parse(value);
+                return result = ['Polygon', 'MultiPolygon'].includes(data.type)
+                    ? {
+                        type: 'Feature',
+                        geometry: data
+                    }
+                    : data;
+            }
+            catch (e2) { }
+        }
+        return result ? validateGeoJSONFormat(result) : value;
     }
 };
 var getPropertyDefinition = function (schema, key, ignoreErrors, value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/schema-convert",
-  "version": "9.2.0",
+  "version": "9.5.0",
   "description": "Hestia Schema Converters",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -28,6 +28,7 @@
   "dependencies": {
     "@hestia-earth/json-schema": "*",
     "@hestia-earth/schema": "*",
+    "@terraformer/wkt": "^2.1.1",
     "csvtojson": "^2.0.0",
     "fast-levenshtein": "^3.0.0",
     "json-2-csv": "^3.14.0",