geonetwork-ui 2.1.0-initial

package/esm2022/libs/util/app-config/src/lib/parse-utils.mjs

@@ -0,0 +1,88 @@
+import { LANGUAGE_CODES_ISO_3 } from './constants';
+const flatten = (base, obj, keepLevel = false) => Object.keys(obj).reduce((prev, curr) => {
+    const path = base ? `${base}.${curr}` : curr;
+    const val = obj[curr];
+    if (keepLevel) {
+        return { ...prev, [path]: flatten('', val) };
+    }
+    else if (typeof val === 'object' && !Array.isArray(val)) {
+        return {
+            ...prev,
+            ...flatten(path, val),
+        };
+    }
+    else {
+        return { ...prev, [path]: val };
+    }
+}, {});
+const checkKeys = (input, mandatory, optional) => {
+    const keys = Object.keys(input);
+    const missing = mandatory.filter((key) => keys.indexOf(key) === -1);
+    const unrecognized = keys.filter((key) => mandatory.indexOf(key) === -1 && optional.indexOf(key) === -1);
+    return {
+        missing,
+        unrecognized,
+    };
+};
+/**
+ * Only keeps recognized keys, flatten nested values (to allow having "." in keys),
+ * pushes warnings and errors to the given arrays; returns null in case of error
+ */
+export function parseConfigSection(fullConfigObj, sectionName, mandatoryKeys, optionalKeys, outWarnings, outErrors) {
+    if (typeof fullConfigObj[sectionName] !== 'object') {
+        if (mandatoryKeys.length === 0)
+            return null;
+        outErrors.push(`The [${sectionName}] mandatory section is missing.`);
+        return null;
+    }
+    const sectionConf = fullConfigObj[sectionName];
+    const keysCheck = checkKeys(sectionConf, mandatoryKeys, optionalKeys);
+    if (keysCheck.missing.length) {
+        // note: this is not thrown to allow merging several Errors down the line
+        outErrors.push(`In the [${sectionName}] section: ${keysCheck.missing.join(', ')}`);
+        return null;
+    }
+    else if (keysCheck.unrecognized.length) {
+        outWarnings.push(`In the [${sectionName}] section: ${keysCheck.unrecognized.join(', ')}`);
+        keysCheck.unrecognized.forEach((key) => delete sectionConf[key]);
+    }
+    return sectionConf;
+}
+/**
+ * Same as parseConfigSection but keeps all keys, recognized or not
+ * Also the first level is the language code (e.g. 'en')
+ * This is optional
+ */
+export function parseTranslationsConfigSection(fullConfigObj, sectionName) {
+    if (typeof fullConfigObj[sectionName] !== 'object') {
+        return {};
+    }
+    return flatten('', fullConfigObj[sectionName], true);
+}
+/**
+ * Same as parseConfigSection but handles an array of configs; this is
+ * considered optional; returns null in case of error in at least one of
+ * the sections
+ */
+export function parseMultiConfigSection(fullConfigObj, sectionName, mandatoryKeys, optionalKeys, outWarnings, outErrors) {
+    const sections = fullConfigObj[sectionName];
+    if (!sections) {
+        return [];
+    }
+    if (!Array.isArray(sections)) {
+        outErrors.push(`Expected [[${sectionName}]] to be an array of sections.`);
+        return null;
+    }
+    const result = sections.map((section) => parseConfigSection({ [sectionName]: section }, sectionName, mandatoryKeys, optionalKeys, outWarnings, outErrors));
+    if (result.some((r) => r === null)) {
+        return null;
+    }
+    return result;
+}
+export function checkMetadataLanguage(parsedConfigSection, outWarnings) {
+    if (LANGUAGE_CODES_ISO_3.indexOf(parsedConfigSection.metadata_language.toLowerCase()) === -1) {
+        outWarnings.push(`In the [global] section: metadata_language = "${parsedConfigSection.metadata_language}" is not in ISO 639-2/B format`);
+    }
+    return parsedConfigSection;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse-utils.js","sourceRoot":"","sources":["../../../../../../../libs/util/app-config/src/lib/parse-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { LANGUAGE_CODES_ISO_3 } from './constants'\n\nconst flatten = (\n  base: string,\n  obj: Record<string, unknown>,\n  keepLevel = false\n) =>\n  Object.keys(obj).reduce((prev, curr) => {\n    const path = base ? `${base}.${curr}` : curr\n    const val = obj[curr]\n    if (keepLevel) {\n      return { ...prev, [path]: flatten('', val as Record<string, unknown>) }\n    } else if (typeof val === 'object' && !Array.isArray(val)) {\n      return {\n        ...prev,\n        ...flatten(path, val as Record<string, unknown>),\n      }\n    } else {\n      return { ...prev, [path]: val }\n    }\n  }, {})\n\nconst checkKeys = (\n  input: Record<string, string>,\n  mandatory: string[],\n  optional: string[]\n) => {\n  const keys = Object.keys(input)\n  const missing = mandatory.filter((key) => keys.indexOf(key) === -1)\n  const unrecognized = keys.filter(\n    (key) => mandatory.indexOf(key) === -1 && optional.indexOf(key) === -1\n  )\n  return {\n    missing,\n    unrecognized,\n  }\n}\n\n/**\n * Only keeps recognized keys, flatten nested values (to allow having \".\" in keys),\n * pushes warnings and errors to the given arrays; returns null in case of error\n */\nexport function parseConfigSection(\n  fullConfigObj: Record<string, Record<string, unknown>>,\n  sectionName: string,\n  mandatoryKeys: string[],\n  optionalKeys: string[],\n  outWarnings: string[],\n  outErrors: string[]\n): Record<string, unknown> | null {\n  if (typeof fullConfigObj[sectionName] !== 'object') {\n    if (mandatoryKeys.length === 0) return null\n    outErrors.push(`The [${sectionName}] mandatory section is missing.`)\n    return null\n  }\n\n  const sectionConf = fullConfigObj[sectionName] as Record<string, string>\n  const keysCheck = checkKeys(sectionConf, mandatoryKeys, optionalKeys)\n\n  if (keysCheck.missing.length) {\n    // note: this is not thrown to allow merging several Errors down the line\n    outErrors.push(\n      `In the [${sectionName}] section: ${keysCheck.missing.join(', ')}`\n    )\n    return null\n  } else if (keysCheck.unrecognized.length) {\n    outWarnings.push(\n      `In the [${sectionName}] section: ${keysCheck.unrecognized.join(', ')}`\n    )\n    keysCheck.unrecognized.forEach((key) => delete sectionConf[key])\n  }\n\n  return sectionConf\n}\n\n/**\n * Same as parseConfigSection but keeps all keys, recognized or not\n * Also the first level is the language code (e.g. 'en')\n * This is optional\n */\nexport function parseTranslationsConfigSection(\n  fullConfigObj: Record<string, Record<string, unknown>>,\n  sectionName: string\n): Record<string, unknown> {\n  if (typeof fullConfigObj[sectionName] !== 'object') {\n    return {}\n  }\n  return flatten('', fullConfigObj[sectionName], true)\n}\n\n/**\n * Same as parseConfigSection but handles an array of configs; this is\n * considered optional; returns null in case of error in at least one of\n * the sections\n */\nexport function parseMultiConfigSection(\n  fullConfigObj: Record<string, Record<string, unknown>[]>,\n  sectionName: string,\n  mandatoryKeys: string[],\n  optionalKeys: string[],\n  outWarnings: string[],\n  outErrors: string[]\n): Record<string, unknown>[] | null {\n  const sections = fullConfigObj[sectionName]\n  if (!sections) {\n    return []\n  }\n  if (!Array.isArray(sections)) {\n    outErrors.push(`Expected [[${sectionName}]] to be an array of sections.`)\n    return null\n  }\n  const result = sections.map((section) =>\n    parseConfigSection(\n      { [sectionName]: section },\n      sectionName,\n      mandatoryKeys,\n      optionalKeys,\n      outWarnings,\n      outErrors\n    )\n  )\n  if (result.some((r) => r === null)) {\n    return null\n  }\n  return result\n}\n\nexport function checkMetadataLanguage(\n  parsedConfigSection: any,\n  outWarnings: string[]\n) {\n  if (\n    LANGUAGE_CODES_ISO_3.indexOf(\n      parsedConfigSection.metadata_language.toLowerCase()\n    ) === -1\n  ) {\n    outWarnings.push(\n      `In the [global] section: metadata_language = \"${parsedConfigSection.metadata_language}\" is not in ISO 639-2/B format`\n    )\n  }\n  return parsedConfigSection\n}\n"]}

package/esm2022/libs/util/data-fetcher/src/index.mjs

@@ -0,0 +1,5 @@
+export * from './lib/data-fetcher';
+export { SupportedTypes, FetchError, } from './lib/model';
+export { getJsonDataItemsProxy } from './lib/utils';
+export { BaseReader } from './lib/readers/base';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3V0aWwvZGF0YS1mZXRjaGVyL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFBO0FBQ2xDLE9BQU8sRUFFTCxjQUFjLEVBRWQsVUFBVSxHQUVYLE1BQU0sYUFBYSxDQUFBO0FBQ3BCLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGFBQWEsQ0FBQTtBQUNuRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sb0JBQW9CLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9kYXRhLWZldGNoZXInXG5leHBvcnQge1xuICBTdXBwb3J0ZWRUeXBlLFxuICBTdXBwb3J0ZWRUeXBlcyxcbiAgRGF0YUl0ZW0sXG4gIEZldGNoRXJyb3IsXG4gIEZpZWxkQWdncmVnYXRpb24sXG59IGZyb20gJy4vbGliL21vZGVsJ1xuZXhwb3J0IHsgZ2V0SnNvbkRhdGFJdGVtc1Byb3h5IH0gZnJvbSAnLi9saWIvdXRpbHMnXG5leHBvcnQgeyBCYXNlUmVhZGVyIH0gZnJvbSAnLi9saWIvcmVhZGVycy9iYXNlJ1xuIl19

package/esm2022/libs/util/data-fetcher/src/lib/data-fetcher.mjs

@@ -0,0 +1,61 @@
+import { parseHeaders } from './headers';
+import { CsvReader } from './readers/csv';
+import { JsonReader } from './readers/json';
+import { GeojsonReader } from './readers/geojson';
+import { ExcelReader } from './readers/excel';
+import { FetchError } from './model';
+import { inferDatasetType } from './utils';
+import { GmlReader } from './readers/gml';
+export async function openDataset(url, typeHint, options) {
+    const fileType = await inferDatasetType(url, typeHint);
+    let reader;
+    try {
+        switch (fileType) {
+            case 'csv':
+                reader = new CsvReader(url);
+                break;
+            case 'json':
+                reader = new JsonReader(url);
+                break;
+            case 'geojson':
+                reader = new GeojsonReader(url);
+                break;
+            case 'excel':
+                reader = new ExcelReader(url);
+                break;
+            case 'gml':
+                reader = new GmlReader(url, options.namespace, options.wfsVersion);
+                break;
+        }
+        reader.load();
+        return reader;
+    }
+    catch (e) {
+        throw FetchError.parsingFailed(e.message);
+    }
+}
+/**
+ * This fetches the full dataset at the given URL and parses it according to its mime type.
+ * All items in the dataset are converted to GeoJSON features, even if they do not bear any spatial geometry.
+ * File type can be either inferred (from the HTTP headers or the URL), or hinted using the 2nd argument
+ * File type is determined liked so:
+ *  1. if a type hint is given, use it
+ *  2. otherwise, look for a Content-Type header in the response with a supported mime type
+ *  3. if no valid mime type was found, look for an explicit file extension in the url (.csv, .geojson etc.)
+ */
+export async function readDataset(url, typeHint, options) {
+    const reader = await openDataset(url, typeHint, options);
+    try {
+        return await reader.read();
+    }
+    catch (e) {
+        throw FetchError.parsingFailed(e.message);
+    }
+}
+/**
+ * This fetches only the header of the dataset at the given URL, giving info on size, mime-type and last update if available.
+ */
+export function readDatasetHeaders(url) {
+    return fetch(url).then((response) => parseHeaders(response.headers));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/headers.mjs

@@ -0,0 +1,22 @@
+import { AllMimeTypes, SupportedTypes } from './model';
+export function parseHeaders(httpHeaders) {
+    const result = {};
+    if (httpHeaders.has('Content-Type')) {
+        result.mimeType = httpHeaders.get('Content-Type').split(';')[0];
+        const supported = SupportedTypes.filter((type) => AllMimeTypes[type].indexOf(result.mimeType) > -1)[0] || null;
+        if (supported !== null)
+            result.supportedType = supported;
+    }
+    if (httpHeaders.has('Content-Length')) {
+        result.fileSizeBytes = parseInt(httpHeaders.get('Content-Length'));
+    }
+    if (httpHeaders.has('Last-Modified')) {
+        const date = new Date(httpHeaders.get('Last-Modified'));
+        if (Number.isNaN(date.valueOf()))
+            result.lastUpdateInvalid = true;
+        else
+            result.lastUpdate = date;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/model.mjs

@@ -0,0 +1,54 @@
+export class FetchError {
+    constructor(type, info, httpStatus = 0) {
+        this.type = type;
+        this.info = info;
+        this.httpStatus = httpStatus;
+        this.stack = null;
+        this.message = `An error happened in the data fetcher, type: ${type}, info: ${info}`;
+    }
+    static http(code) {
+        return new FetchError('http', '', code);
+    }
+    static corsOrNetwork(message) {
+        return new FetchError('network', message, 0);
+    }
+    static parsingFailed(info) {
+        return new FetchError('parse', info, 0);
+    }
+    static unsupportedType(mimeType) {
+        return new FetchError('unsupportedType', mimeType, 0);
+    }
+    static unknownType() {
+        return new FetchError('unknown', '', 0);
+    }
+}
+// Useful reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+export const CsvMimeTypes = [
+    'text/csv',
+    'application/csv', // seems to be also common
+];
+export const JsonMimeTypes = ['application/json'];
+export const GeoJsonMimeTypes = [
+    'application/geo+json',
+    'application/vnd.geo+json',
+];
+export const ExcelMimeTypes = [
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // .xslx
+];
+export const GmlMimeTypes = ['application/gml+xml'];
+export const SupportedTypes = [
+    'csv',
+    'json',
+    'geojson',
+    'excel',
+    'gml',
+];
+export const AllMimeTypes = {
+    csv: CsvMimeTypes,
+    json: JsonMimeTypes,
+    geojson: GeoJsonMimeTypes,
+    excel: ExcelMimeTypes,
+    gml: GmlMimeTypes,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/base-file.mjs

@@ -0,0 +1,37 @@
+import { BaseReader } from './base';
+import { getJsonDataItemsProxy, jsonToGeojsonFeature } from '../utils';
+import { generateSqlQuery } from '../sql-utils';
+export class BaseFileReader extends BaseReader {
+    getData() {
+        throw new Error('not implemented');
+    }
+    load() {
+        this.parseResult_ = this.getData();
+    }
+    get properties() {
+        return this.parseResult_.then((result) => result.properties);
+    }
+    get info() {
+        return this.parseResult_.then((result) => ({
+            itemsCount: result.items.length,
+        }));
+    }
+    async read() {
+        const items = (await this.parseResult_).items;
+        // no query defined: return the full results as is
+        if (this.groupedBy == null &&
+            this.aggregations == null &&
+            this.selected == null &&
+            this.sort == null &&
+            this.filter == null &&
+            this.startIndex == null &&
+            this.count == null) {
+            return items;
+        }
+        const jsonItems = getJsonDataItemsProxy(items);
+        const query = generateSqlQuery(this.selected, this.filter, this.sort, this.startIndex, this.count, this.groupedBy, this.aggregations);
+        const result = await import('alasql').then((module) => module.default(query, [jsonItems]));
+        return result.map(jsonToGeojsonFeature);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/base.mjs

@@ -0,0 +1,62 @@
+export class BaseReader {
+    constructor(url) {
+        this.url = url;
+        this.selected = null;
+        this.groupedBy = null;
+        this.aggregations = null;
+        this.filter = null;
+        this.sort = null;
+        this.startIndex = null;
+        this.count = null;
+    }
+    load() {
+        throw new Error('not implemented');
+    }
+    get properties() {
+        throw new Error('not implemented');
+    }
+    get info() {
+        throw new Error('not implemented');
+    }
+    read() {
+        throw new Error('not implemented');
+    }
+    selectAll() {
+        this.groupedBy = null;
+        this.aggregations = null;
+        this.selected = null;
+        this.filter = null;
+        this.startIndex = null;
+        this.count = null;
+        return this;
+    }
+    select(...selectedFields) {
+        this.selected = selectedFields;
+        this.aggregations = null; // clear aggregations & groups when selecting fields
+        this.groupedBy = null;
+        return this;
+    }
+    groupBy(...groupBy) {
+        this.groupedBy = groupBy;
+        this.selected = null; // clear normal field selection when aggregating
+        return this;
+    }
+    aggregate(...aggregations) {
+        this.aggregations = aggregations;
+        return this;
+    }
+    where(filter) {
+        this.filter = filter;
+        return this;
+    }
+    orderBy(...fieldSorts) {
+        this.sort = fieldSorts;
+        return this;
+    }
+    limit(startIndex, count) {
+        this.startIndex = startIndex;
+        this.count = count;
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/csv.mjs

@@ -0,0 +1,37 @@
+import * as Papa from 'papaparse';
+import { fetchDataAsText, jsonToGeojsonFeature, processItemProperties, } from '../utils';
+import { BaseFileReader } from './base-file';
+export function parseCsv(text) {
+    // first parse the header to guess the delimiter
+    // note that we do that to not rely on Papaparse logic for guessing delimiter
+    let delimiter;
+    try {
+        const header = text.split('\n')[0];
+        const result = Papa.parse(header, {
+            header: false,
+        });
+        delimiter = result.meta.delimiter;
+    }
+    catch (e) {
+        throw new Error('CSV parsing failed: the delimiter could not be guessed');
+    }
+    const parsed = Papa.parse(text, {
+        header: true,
+        skipEmptyLines: true,
+        delimiter,
+    });
+    if (parsed.errors.length) {
+        throw new Error('CSV parsing failed for the following reasons:\n' +
+            parsed.errors
+                .map((error) => `* ${error.message} at row ${error.row}, column ${error.index}`)
+                .join('\n'));
+    }
+    const items = parsed.data.map(jsonToGeojsonFeature);
+    return processItemProperties(items, true);
+}
+export class CsvReader extends BaseFileReader {
+    getData() {
+        return fetchDataAsText(this.url).then(parseCsv);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/excel.mjs

@@ -0,0 +1,24 @@
+import { fetchDataAsArrayBuffer, jsonToGeojsonFeature, processItemProperties, } from '../utils';
+import { BaseFileReader } from './base-file';
+/**
+ * This will read the first sheet of the excel workbook and expect the first
+ * line to contain the properties names
+ * @param buffer
+ */
+export function parseExcel(buffer) {
+    return import('xlsx').then(({ read, utils }) => {
+        const workbook = read(buffer);
+        const sheet = workbook.Sheets[workbook.SheetNames[0]];
+        let json = utils.sheet_to_json(sheet);
+        if (!json.length) {
+            json = [];
+        }
+        return processItemProperties(json.map(jsonToGeojsonFeature), true);
+    });
+}
+export class ExcelReader extends BaseFileReader {
+    getData() {
+        return fetchDataAsArrayBuffer(this.url).then(parseExcel);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/geojson.mjs

@@ -0,0 +1,21 @@
+import { fetchDataAsText, processItemProperties } from '../utils';
+import { BaseFileReader } from './base-file';
+/**
+ * This parser supports both Geojson Feature collections or arrays
+ * of Features
+ * @param text
+ */
+export function parseGeojson(text) {
+    const parsed = JSON.parse(text);
+    const features = parsed.type === 'FeatureCollection' ? parsed.features : parsed;
+    if (!Array.isArray(features)) {
+        throw new Error('Could not parse GeoJSON, expected a features collection or an array of features at root level');
+    }
+    return processItemProperties(features);
+}
+export class GeojsonReader extends BaseFileReader {
+    getData() {
+        return fetchDataAsText(this.url).then(parseGeojson);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/gml.mjs

@@ -0,0 +1,36 @@
+import { BaseFileReader } from './base-file';
+import { fetchDataAsText, processItemProperties } from '../utils';
+import { GeoJSON, WFS } from 'ol/format';
+export function parseGml(text, namespace, version) {
+    const splittedNamespace = namespace.split(':');
+    const regex = new RegExp(`xmlns:${splittedNamespace[0]}=["']([^'"]*)["']`);
+    const match = regex.exec(text);
+    if (match && match.length >= 2) {
+        const wf = new WFS({
+            featureNS: match[1],
+            featureType: splittedNamespace[1],
+            version: version,
+        });
+        let features;
+        try {
+            features = wf.readFeatures(text);
+        }
+        catch (e) {
+            throw Error("Couldn't parse WFS with GML features");
+        }
+        const geojsonItem = new GeoJSON().writeFeaturesObject(features);
+        return processItemProperties(geojsonItem.features, true);
+    }
+    throw Error("Couldn't retrieve namespace url");
+}
+export class GmlReader extends BaseFileReader {
+    constructor(url, namespace, version) {
+        super(url);
+        this.namespace = namespace;
+        this.version = version;
+    }
+    getData() {
+        return fetchDataAsText(this.url).then((text) => parseGml(text, this.namespace, this.version));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/libs/util/data-fetcher/src/lib/readers/json.mjs

@@ -0,0 +1,19 @@
+import { fetchDataAsText, jsonToGeojsonFeature, processItemProperties, } from '../utils';
+import { BaseFileReader } from './base-file';
+/**
+ * This parser only supports arrays of simple flat objects with properties
+ * @param text
+ */
+export function parseJson(text) {
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed)) {
+        throw new Error('Could not parse JSON, expected an array at root level');
+    }
+    return processItemProperties(parsed.map(jsonToGeojsonFeature));
+}
+export class JsonReader extends BaseFileReader {
+    getData() {
+        return fetchDataAsText(this.url).then(parseJson);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvdXRpbC9kYXRhLWZldGNoZXIvc3JjL2xpYi9yZWFkZXJzL2pzb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUNMLGVBQWUsRUFDZixvQkFBb0IsRUFDcEIscUJBQXFCLEdBQ3RCLE1BQU0sVUFBVSxDQUFBO0FBQ2pCLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxhQUFhLENBQUE7QUFFNUM7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLFNBQVMsQ0FBQyxJQUFZO0lBSXBDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFVLENBQUE7SUFDeEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEVBQUU7UUFDMUIsTUFBTSxJQUFJLEtBQUssQ0FBQyx1REFBdUQsQ0FBQyxDQUFBO0tBQ3pFO0lBQ0QsT0FBTyxxQkFBcUIsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLG9CQUFvQixDQUFDLENBQUMsQ0FBQTtBQUNoRSxDQUFDO0FBRUQsTUFBTSxPQUFPLFVBQVcsU0FBUSxjQUFjO0lBQzVDLE9BQU87UUFDTCxPQUFPLGVBQWUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO0lBQ2xELENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERhdGFJdGVtLCBQcm9wZXJ0eUluZm8gfSBmcm9tICcuLi9tb2RlbCdcbmltcG9ydCB7XG4gIGZldGNoRGF0YUFzVGV4dCxcbiAganNvblRvR2VvanNvbkZlYXR1cmUsXG4gIHByb2Nlc3NJdGVtUHJvcGVydGllcyxcbn0gZnJvbSAnLi4vdXRpbHMnXG5pbXBvcnQgeyBCYXNlRmlsZVJlYWRlciB9IGZyb20gJy4vYmFzZS1maWxlJ1xuXG4vKipcbiAqIFRoaXMgcGFyc2VyIG9ubHkgc3VwcG9ydHMgYXJyYXlzIG9mIHNpbXBsZSBmbGF0IG9iamVjdHMgd2l0aCBwcm9wZXJ0aWVzXG4gKiBAcGFyYW0gdGV4dFxuICovXG5leHBvcnQgZnVuY3Rpb24gcGFyc2VKc29uKHRleHQ6IHN0cmluZyk6IHtcbiAgaXRlbXM6IERhdGFJdGVtW11cbiAgcHJvcGVydGllczogUHJvcGVydHlJbmZvW11cbn0ge1xuICBjb25zdCBwYXJzZWQgPSBKU09OLnBhcnNlKHRleHQpIGFzIGFueVtdXG4gIGlmICghQXJyYXkuaXNBcnJheShwYXJzZWQpKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdDb3VsZCBub3QgcGFyc2UgSlNPTiwgZXhwZWN0ZWQgYW4gYXJyYXkgYXQgcm9vdCBsZXZlbCcpXG4gIH1cbiAgcmV0dXJuIHByb2Nlc3NJdGVtUHJvcGVydGllcyhwYXJzZWQubWFwKGpzb25Ub0dlb2pzb25GZWF0dXJlKSlcbn1cblxuZXhwb3J0IGNsYXNzIEpzb25SZWFkZXIgZXh0ZW5kcyBCYXNlRmlsZVJlYWRlciB7XG4gIGdldERhdGEoKSB7XG4gICAgcmV0dXJuIGZldGNoRGF0YUFzVGV4dCh0aGlzLnVybCkudGhlbihwYXJzZUpzb24pXG4gIH1cbn1cbiJdfQ==