@loaders.gl/wms 4.0.0-alpha.23 → 4.0.0-alpha.24

package/dist/lib/parsers/gml/parse-gml.js

@@ -1,371 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMultiSurface = exports.parseCompositeSurface = exports.parseSurface = exports.parsePolygonOrRectangle = exports.parseExteriorOrInterior = exports.parseRing = exports.parseCurveSegments = exports.parseLinearRingOrLineString = exports.parsePoint = exports.parsePos = exports.parsePosList = exports.parseGMLToGeometry = exports.parseGML = void 0;
-const xml_1 = require("@loaders.gl/xml");
-const deep_strict_equal_1 = require("./deep-strict-equal");
-const rewind_1 = __importDefault(require("@turf/rewind"));
-function noTransform(...coords) {
-    return coords;
-}
-/**
- * Parses a typed data structure from raw XML for GML features
- * @note Error handlings is fairly weak
- */
-function parseGML(text, options) {
-    // GeoJSON | null {
-    const parsedXML = xml_1.XMLLoader.parseTextSync?.(text, options);
-    options = { transformCoords: noTransform, stride: 2, ...options };
-    const context = createChildContext(parsedXML, options, {});
-    return parseGMLToGeometry(parsedXML, options, context);
-}
-exports.parseGML = parseGML;
-/** Parse a GeoJSON geometry from GML XML */
-function parseGMLToGeometry(inputXML, options, context) {
-    const childContext = createChildContext(inputXML, options, context);
-    let geometry = null;
-    const [name, xml] = getFirstKeyValue(inputXML);
-    switch (name) {
-        // case 'gml:MultiPoint':
-        //   geometry = {
-        //     type: 'MultiPoint',
-        //     coordinates: parseMultiPoint(xml, options, childContext)
-        //   };
-        //   break;
-        case 'gml:LineString':
-            geometry = {
-                type: 'LineString',
-                coordinates: parseLinearRingOrLineString(xml, options, childContext)
-            };
-            break;
-        // case 'gml:MultiLineString':
-        //   geometry = {
-        //     type: 'MultiLineString',
-        //     coordinates: parseMultiLineString(xml, options, childContext)
-        //   };
-        //   break;
-        case 'gml:Polygon':
-        case 'gml:Rectangle':
-            geometry = {
-                type: 'Polygon',
-                coordinates: parsePolygonOrRectangle(xml, options, childContext)
-            };
-            break;
-        case 'gml:Surface':
-            geometry = {
-                type: 'MultiPolygon',
-                coordinates: parseSurface(xml, options, childContext)
-            };
-            break;
-        case 'gml:MultiSurface':
-            geometry = {
-                type: 'MultiPolygon',
-                coordinates: parseMultiSurface(xml, options, childContext)
-            };
-            break;
-        default:
-            return null;
-    }
-    // todo
-    return (0, rewind_1.default)(geometry, { mutate: true });
-}
-exports.parseGMLToGeometry = parseGMLToGeometry;
-/** Parse a list of coordinates from a string */
-function parseCoords(s, options, context) {
-    const stride = context.srsDimension || options.stride || 2;
-    // Handle white space
-    const coords = s.replace(/\s+/g, ' ').trim().split(' ');
-    if (coords.length === 0 || coords.length % stride !== 0) {
-        throw new Error(`invalid coordinates list (stride ${stride})`);
-    }
-    const points = [];
-    for (let i = 0; i < coords.length - 1; i += stride) {
-        const point = coords.slice(i, i + stride).map(parseFloat);
-        points.push(options.transformCoords?.(...point) || point);
-    }
-    return points;
-}
-function parsePosList(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    const coords = textOf(xml);
-    if (!coords) {
-        throw new Error('invalid gml:posList element');
-    }
-    return parseCoords(coords, options, childContext);
-}
-exports.parsePosList = parsePosList;
-function parsePos(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    const coords = textOf(xml);
-    if (!coords) {
-        throw new Error('invalid gml:pos element');
-    }
-    const points = parseCoords(coords, options, childContext);
-    if (points.length !== 1) {
-        throw new Error('gml:pos must have 1 point');
-    }
-    return points[0];
-}
-exports.parsePos = parsePos;
-function parsePoint(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    // TODO AV: Parse other gml:Point options
-    const pos = findIn(xml, 'gml:pos');
-    if (!pos) {
-        throw new Error('invalid gml:Point element, expected a gml:pos subelement');
-    }
-    return parsePos(pos, options, childContext);
-}
-exports.parsePoint = parsePoint;
-function parseLinearRingOrLineString(xml, options, context) {
-    // or a LineStringSegment
-    const childContext = createChildContext(xml, options, context);
-    let points = [];
-    const posList = findIn(xml, 'gml:posList');
-    if (posList) {
-        points = parsePosList(posList, options, childContext);
-    }
-    else {
-        for (const [childName, childXML] of Object.entries(xml)) {
-            switch (childName) {
-                case 'gml:Point':
-                    points.push(parsePoint(childXML, options, childContext));
-                    break;
-                case 'gml:pos':
-                    points.push(parsePos(childXML, options, childContext));
-                    break;
-                default:
-                    continue;
-            }
-        }
-    }
-    if (points.length === 0) {
-        throw new Error(`${xml.name} must have > 0 points`);
-    }
-    return points;
-}
-exports.parseLinearRingOrLineString = parseLinearRingOrLineString;
-function parseCurveSegments(xml, options, context) {
-    const points = [];
-    for (const [childName, childXML] of Object.entries(xml)) {
-        switch (childName) {
-            case 'gml:LineStringSegment':
-                const points2 = parseLinearRingOrLineString(childXML, options, context);
-                // remove overlapping
-                const end = points[points.length - 1];
-                const start = points2[0];
-                if (end && start && (0, deep_strict_equal_1.deepStrictEqual)(end, start)) {
-                    points2.shift();
-                }
-                points.push(...points2);
-                break;
-            default:
-                continue;
-        }
-    }
-    if (points.length === 0) {
-        throw new Error('gml:Curve > gml:segments must have > 0 points');
-    }
-    return points;
-}
-exports.parseCurveSegments = parseCurveSegments;
-function parseRing(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    const points = [];
-    for (const [childName, childXML] of Object.entries(xml)) {
-        switch (childName) {
-            case 'gml:curveMember':
-                let points2;
-                const lineString = findIn(childXML, 'gml:LineString');
-                if (lineString) {
-                    points2 = parseLinearRingOrLineString(lineString, options, childContext);
-                }
-                else {
-                    const segments = findIn(childXML, 'gml:Curve', 'gml:segments');
-                    if (!segments) {
-                        throw new Error(`invalid ${childName} element`);
-                    }
-                    points2 = parseCurveSegments(segments, options, childContext);
-                }
-                // remove overlapping
-                const end = points[points.length - 1];
-                const start = points2[0];
-                if (end && start && (0, deep_strict_equal_1.deepStrictEqual)(end, start)) {
-                    points2.shift();
-                }
-                points.push(...points2);
-                break;
-        }
-    }
-    if (points.length < 4) {
-        throw new Error(`${xml.name} must have >= 4 points`);
-    }
-    return points;
-}
-exports.parseRing = parseRing;
-function parseExteriorOrInterior(xml, options, context) {
-    const linearRing = findIn(xml, 'gml:LinearRing');
-    if (linearRing) {
-        return parseLinearRingOrLineString(linearRing, options, context);
-    }
-    const ring = findIn(xml, 'gml:Ring');
-    if (!ring) {
-        throw new Error(`invalid ${xml.name} element`);
-    }
-    return parseRing(ring, options, context);
-}
-exports.parseExteriorOrInterior = parseExteriorOrInterior;
-function parsePolygonOrRectangle(xml, options, context) {
-    // or PolygonPatch
-    const childContext = createChildContext(xml, options, context);
-    const exterior = findIn(xml, 'gml:exterior');
-    if (!exterior) {
-        throw new Error(`invalid ${xml.name} element`);
-    }
-    const pointLists = [parseExteriorOrInterior(exterior, options, childContext)];
-    for (const [childName, childXML] of Object.entries(xml)) {
-        switch (childName) {
-            case 'gml:interior':
-                pointLists.push(parseExteriorOrInterior(childXML, options, childContext));
-                break;
-        }
-    }
-    return pointLists;
-}
-exports.parsePolygonOrRectangle = parsePolygonOrRectangle;
-function parseSurface(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    const patches = findIn(xml, 'gml:patches');
-    if (!patches) {
-        throw new Error(`invalid ${xml.name} element`);
-    }
-    const polygons = [];
-    for (const [childName, childXML] of Object.entries(xml)) {
-        switch (childName) {
-            case 'gml:PolygonPatch':
-            case 'gml:Rectangle':
-                polygons.push(parsePolygonOrRectangle(childXML, options, childContext));
-                break;
-            default:
-                continue;
-        }
-    }
-    if (polygons.length === 0) {
-        throw new Error(`${xml.name} must have > 0 polygons`);
-    }
-    return polygons;
-}
-exports.parseSurface = parseSurface;
-function parseCompositeSurface(xml, options, context) {
-    const childContext = createChildContext(xml, options, context);
-    const polygons = [];
-    for (const [childName, childXML] of Object.entries(xml)) {
-        switch (childName) {
-            case 'gml:surfaceMember':
-            case 'gml:surfaceMembers':
-                const [c2Name, c2Xml] = getFirstKeyValue(childXML);
-                switch (c2Name) {
-                    case 'gml:Surface':
-                        polygons.push(...parseSurface(c2Xml, options, childContext));
-                        break;
-                    case 'gml:Polygon':
-                        polygons.push(parsePolygonOrRectangle(c2Xml, options, childContext));
-                        break;
-                }
-                break;
-        }
-    }
-    if (polygons.length === 0) {
-        throw new Error(`${xml.name} must have > 0 polygons`);
-    }
-    return polygons;
-}
-exports.parseCompositeSurface = parseCompositeSurface;
-function parseMultiSurface(xml, options, context) {
-    let el = xml;
-    const surfaceMembers = findIn(xml, 'gml:LinearRing');
-    if (surfaceMembers) {
-        el = surfaceMembers;
-    }
-    const polygons = [];
-    for (const [childName, childXML] of Object.entries(el)) {
-        switch (childName) {
-            case 'gml:Surface':
-                const polygons2 = parseSurface(childXML, options, context);
-                polygons.push(...polygons2);
-                break;
-            case 'gml:surfaceMember':
-                const polygons3 = parseSurfaceMember(childXML, options, context);
-                polygons.push(...polygons3);
-                break;
-            case 'gml:surfaceMembers':
-                const polygonXML = findIn(childXML, 'gml:Polygon');
-                for (const surfaceMemberXML of polygonXML) {
-                    const polygons3 = parseSurfaceMember(surfaceMemberXML, options, context);
-                    polygons.push(...polygons3);
-                }
-                break;
-        }
-    }
-    if (polygons.length === 0) {
-        throw new Error(`${xml.name} must have > 0 polygons`);
-    }
-    return polygons;
-}
-exports.parseMultiSurface = parseMultiSurface;
-function parseSurfaceMember(xml, options, context) {
-    const [childName, childXml] = getFirstKeyValue(xml);
-    switch (childName) {
-        case 'gml:CompositeSurface':
-            return parseCompositeSurface(childXml, options, context);
-        case 'gml:Surface':
-            return parseSurface(childXml, options, context);
-        case 'gml:Polygon':
-            return [parsePolygonOrRectangle(childXml, options, context)];
-    }
-    throw new Error(`${childName} must have polygons`);
-}
-// Helpers
-function textOf(el) {
-    if (typeof el !== 'string') {
-        throw new Error('expected string');
-    }
-    return el;
-}
-function findIn(root, ...tags) {
-    let el = root;
-    for (const tag of tags) {
-        const child = el[tag];
-        if (!child) {
-            return null;
-        }
-        el = child;
-    }
-    return el;
-}
-/** @returns the first [key, value] pair in an object, or ['', null] if empty object */
-function getFirstKeyValue(object) {
-    if (object && typeof object === 'object') {
-        for (const [key, value] of Object.entries(object)) {
-            return [key, value];
-        }
-    }
-    return ['', null];
-}
-/** A bit heavyweight for just tracking dimension? */
-function createChildContext(xml, options, context) {
-    const srsDimensionAttribute = xml.attributes && xml.attributes.srsDimension;
-    if (srsDimensionAttribute) {
-        const srsDimension = parseInt(srsDimensionAttribute);
-        if (Number.isNaN(srsDimension) || srsDimension <= 0) {
-            throw new Error(`invalid srsDimension attribute value "${srsDimensionAttribute}", expected a positive integer`);
-        }
-        const childContext = Object.create(context);
-        childContext.srsDimension = srsDimension;
-        return childContext;
-    }
-    return context;
-}

package/dist/lib/parsers/lerc/lerc-types.js

@@ -1,3 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/parsers/wms/parse-wms-capabilities.js

@@ -1,233 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWMSCapabilities = void 0;
-const xml_1 = require("@loaders.gl/xml");
-const parse_xml_helpers_1 = require("../xml/parse-xml-helpers");
-/**
- * Parses a typed data structure from raw XML for `GetCapabilities` response
- * @note Error handlings is fairly weak
- */
-function parseWMSCapabilities(xmlText, options) {
-    const parsedXML = xml_1.XMLLoader.parseTextSync?.(xmlText, options);
-    const xmlCapabilities = parsedXML.WMT_MS_Capabilities || parsedXML.WMS_Capabilities || parsedXML;
-    const capabilities = extractCapabilities(xmlCapabilities);
-    // In case the processed, normalized capabilities do not contain everything,
-    // the user can get the parsed XML structure.
-    if (options?.inheritedLayerProps) {
-        // Traverse layers and inject missing props from parents
-        for (const layer of capabilities.layers) {
-            addInheritedLayerProps(layer, null);
-        }
-        // Not yet implemented
-    }
-    if (options?.includeRawData || options?.raw) {
-        capabilities.raw = xmlCapabilities;
-    }
-    if (options?.includeXMLText) {
-        capabilities.xml = xmlText;
-    }
-    return capabilities;
-}
-exports.parseWMSCapabilities = parseWMSCapabilities;
-/** Extract typed capability data from XML */
-function extractCapabilities(xml) {
-    const capabilities = {
-        version: String(xml.version || ''),
-        name: String(xml.Service?.Name || 'unnamed'),
-        title: xml.Service?.Title ? String(xml.Service?.Title) : undefined,
-        abstract: xml.Service?.Abstract ? String(xml.Service?.Abstract) : undefined,
-        keywords: (0, parse_xml_helpers_1.getXMLStringArray)(xml.Service?.KeywordList?.Keyword),
-        fees: xml.Service?.Fees ? JSON.stringify(xml.Service?.Fees) : undefined,
-        accessConstraints: xml.Service?.AccessConstraints
-            ? JSON.stringify(xml.Service?.AccessConstraints)
-            : undefined,
-        layerLimit: (0, parse_xml_helpers_1.getXMLInteger)(xml.Service?.LayerLimit),
-        maxWidth: (0, parse_xml_helpers_1.getXMLInteger)(xml.Service?.maxWidth),
-        maxHeight: (0, parse_xml_helpers_1.getXMLInteger)(xml.Service?.maxHeight),
-        layers: [],
-        requests: extractRequests(xml.Capability?.Request),
-        exceptions: extractExceptions(xml.Exception)
-        // contact field is a mess of largely irrelevant information, put it last
-        // contact: xml.Service?.Contact ? JSON.stringify(xml.Service?.Contact) : undefined,
-    };
-    // LAYERS
-    const xmlLayers = (0, parse_xml_helpers_1.getXMLArray)(xml.Capability?.Layer);
-    for (const xmlSubLayer of xmlLayers) {
-        capabilities.layers.push(extractLayer(xmlSubLayer));
-    }
-    // Clean up object
-    for (const [key, value] of Object.entries(capabilities)) {
-        if (value === undefined) {
-            delete capabilities[key];
-        }
-    }
-    return capabilities;
-}
-/** Extract typed request metadata from XML requests field */
-function extractRequests(xmlRequests) {
-    const requests = {};
-    for (const [name, xmlRequest] of Object.entries(xmlRequests || {})) {
-        const mimeTypes = (0, parse_xml_helpers_1.getXMLStringArray)(xmlRequest?.Format);
-        requests[name] = { mimeTypes };
-    }
-    return requests;
-}
-function extractExceptions(xmlException) {
-    const xmlExceptionFormats = (0, parse_xml_helpers_1.getXMLArray)(xmlException?.Format);
-    if (xmlExceptionFormats.length > 0) {
-        return {
-            mimeTypes: (0, parse_xml_helpers_1.getXMLStringArray)(xmlException)
-        };
-    }
-    return undefined;
-}
-/** Extract request data */
-// eslint-disable-next-line complexity, max-statements
-function extractLayer(xmlLayer) {
-    const layer = {
-        // All layers must have a title
-        title: String(xmlLayer?.Title || ''),
-        // Name is required only if renderable
-        name: xmlLayer?.Name && String(xmlLayer?.Name),
-        abstract: xmlLayer?.Name && String(xmlLayer?.Abstract),
-        keywords: (0, parse_xml_helpers_1.getXMLStringArray)(xmlLayer.KeywordList?.Keyword)
-    };
-    // WMS 1.3.0 changes SRS to CRS
-    const crs = xmlLayer?.CRS || xmlLayer?.SRS;
-    if (crs && Array.isArray(crs) && crs.every((_) => typeof _ === 'string')) {
-        layer.crs = crs;
-    }
-    // v1.3.0 extract simple geographic bounding box
-    let geographicBoundingBox = xmlLayer?.EX_GeographicBoundingBox && extractEXBoundingBox(xmlLayer?.EX_GeographicBoundingBox);
-    if (geographicBoundingBox) {
-        layer.geographicBoundingBox = geographicBoundingBox;
-    }
-    // v1.1.1 extract simple geographic bounding box
-    geographicBoundingBox =
-        xmlLayer?.LatLonBoundingBox && extractLatLonBoundingBox(xmlLayer?.LatLonBoundingBox);
-    if (geographicBoundingBox) {
-        layer.geographicBoundingBox = geographicBoundingBox;
-    }
-    // Extract per-CRS bounding boxes
-    const boundingBoxes = xmlLayer?.BoundingBox && extractWMSBoundingBoxes(xmlLayer?.BoundingBox);
-    if (boundingBoxes && boundingBoxes.length > 0) {
-        layer.boundingBoxes = boundingBoxes;
-    }
-    // Extract dimensions
-    const xmlDimensions = (0, parse_xml_helpers_1.getXMLArray)(xmlLayer?.Dimension);
-    const dimensions = xmlDimensions.map((xml) => extractDimension(xml));
-    if (dimensions.length) {
-        layer.dimensions = dimensions;
-    }
-    if (xmlLayer?.opaque) {
-        layer.opaque = (0, parse_xml_helpers_1.getXMLBoolean)(xmlLayer?.opaque);
-    }
-    if (xmlLayer?.cascaded) {
-        layer.cascaded = (0, parse_xml_helpers_1.getXMLBoolean)(xmlLayer?.cascaded);
-    }
-    if (xmlLayer?.queryable) {
-        layer.queryable = (0, parse_xml_helpers_1.getXMLBoolean)(xmlLayer?.queryable);
-    }
-    // Single layer is not represented as array in XML
-    const xmlLayers = (0, parse_xml_helpers_1.getXMLArray)(xmlLayer?.Layer);
-    const layers = [];
-    for (const xmlSubLayer of xmlLayers) {
-        layers.push(extractLayer(xmlSubLayer));
-    }
-    if (layers.length > 0) {
-        layer.layers = layers;
-    }
-    // Clean up object
-    for (const [key, value] of Object.entries(layer)) {
-        if (value === undefined) {
-            delete layer[key];
-        }
-    }
-    return layer;
-}
-/** WMS 1.3.0 Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
-function extractEXBoundingBox(xmlBoundingBox) {
-    const { westBoundLongitude: w, northBoundLatitude: n, eastBoundLongitude: e, southBoundLatitude: s } = xmlBoundingBox;
-    return [
-        [w, s],
-        [e, n]
-    ];
-}
-/** WMS 1.1.1 Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
-function extractLatLonBoundingBox(xmlBoundingBox) {
-    const { minx, miny, maxx, maxy } = xmlBoundingBox;
-    return [
-        [minx, miny],
-        [maxx, maxy]
-    ];
-}
-/** Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
-function extractWMSBoundingBoxes(xmlBoundingBoxes) {
-    const xmlBoxes = (0, parse_xml_helpers_1.getXMLArray)(xmlBoundingBoxes);
-    return xmlBoxes.map((xmlBox) => extractWMSBoundingBox(xmlBox));
-}
-/** Loosely defined geospatial bounding box in unspecified CRS for quick content searches */
-function extractWMSBoundingBox(xmlBoundingBox) {
-    const { CRS, SRS, minx, miny, maxx, maxy, resx, resy } = xmlBoundingBox;
-    const boundingBox = {
-        // CRS in 1.3.0, SRS in 1.1.1
-        crs: CRS || SRS,
-        boundingBox: [
-            [(0, parse_xml_helpers_1.getXMLFloat)(minx), (0, parse_xml_helpers_1.getXMLFloat)(miny)],
-            [(0, parse_xml_helpers_1.getXMLFloat)(maxx), (0, parse_xml_helpers_1.getXMLFloat)(maxy)]
-        ]
-    };
-    if (resx) {
-        boundingBox.xResolution = resx;
-    }
-    if (resy) {
-        boundingBox.yResolution = resy;
-    }
-    return boundingBox;
-}
-/**
- * Extracts optional WMS Dimension layer field
- * @param xmlDimension
- * @example <Dimension name="time" units="ISO8601" default="2018-01-01" nearestValue="0">2001-01-01/2018-01-01/P1Y</Dimension>
- * @see https://mapserver.org/ogc/wms_dimension.html
- */
-function extractDimension(xmlDimension) {
-    const { name, units, value: extent } = xmlDimension;
-    const dimension = { name, units, extent };
-    if (xmlDimension.unitSymbol) {
-        dimension.unitSymbol = xmlDimension.unitSymbol;
-    }
-    if (xmlDimension.default) {
-        dimension.defaultValue = xmlDimension.default;
-    }
-    if (xmlDimension.multipleValues) {
-        dimension.multipleValues = (0, parse_xml_helpers_1.getXMLBoolean)(xmlDimension.multipleValues);
-    }
-    if (xmlDimension.nearestValue) {
-        dimension.nearestValue = (0, parse_xml_helpers_1.getXMLBoolean)(xmlDimension.nearestValue);
-    }
-    if (xmlDimension.current) {
-        dimension.current = (0, parse_xml_helpers_1.getXMLBoolean)(xmlDimension.current);
-    }
-    return dimension;
-}
-/** Traverse layers and inject missing props from parents */
-// eslint-disable-next-line complexity
-function addInheritedLayerProps(layer, parent) {
-    if (parent?.geographicBoundingBox && !layer.geographicBoundingBox) {
-        layer.geographicBoundingBox = [...parent.geographicBoundingBox];
-    }
-    if (parent?.crs && !layer.crs) {
-        layer.crs = [...parent.crs];
-    }
-    if (parent?.boundingBoxes && !layer.boundingBoxes) {
-        layer.boundingBoxes = [...parent.boundingBoxes];
-    }
-    if (parent?.dimensions && !layer.dimensions) {
-        layer.dimensions = [...parent.dimensions];
-    }
-    for (const subLayer of layer.layers || []) {
-        addInheritedLayerProps(subLayer, layer);
-    }
-}

package/dist/lib/parsers/wms/parse-wms-error.js

@@ -1,22 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWMSError = void 0;
-const xml_1 = require("@loaders.gl/xml");
-/**
- * Extract an error message from WMS error response XML
- * @param text
- * @param options
- * @returns a string with a human readable message
- */
-function parseWMSError(text, options) {
-    const parsedXML = xml_1.XMLLoader.parseTextSync?.(text, options);
-    const serviceExceptionXML = parsedXML?.ServiceExceptionReport?.ServiceException ||
-        parsedXML?.['ogc:ServiceExceptionReport']?.['ogc:ServiceException'];
-    // Sigh, can be either a string or an object
-    const message = typeof serviceExceptionXML === 'string'
-        ? serviceExceptionXML
-        : serviceExceptionXML.value || serviceExceptionXML.code || 'Unknown error';
-    return message;
-}
-exports.parseWMSError = parseWMSError;

package/dist/lib/parsers/wms/parse-wms-features.js

@@ -1,27 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWMSFeatureInfo = void 0;
-const xml_1 = require("@loaders.gl/xml");
-/**
- * Parses a typed data structure from raw XML for `GetFeatureInfo` response
- * @note Error handlings is fairly weak
- */
-function parseWMSFeatureInfo(text, options) {
-    const parsedXML = xml_1.XMLLoader.parseTextSync?.(text, options);
-    const xmlFeatureInfo = parsedXML.FeatureInfoResponse?.FIELDS || [];
-    const xmlFeatures = Array.isArray(xmlFeatureInfo) ? xmlFeatureInfo : [xmlFeatureInfo];
-    return {
-        features: xmlFeatures.map((xmlFeature) => extractFeature(xmlFeature))
-    };
-}
-exports.parseWMSFeatureInfo = parseWMSFeatureInfo;
-function extractFeature(xmlFeature) {
-    const xmlFields = xmlFeature || {};
-    // TODO - not correct
-    return {
-        attributes: xmlFields,
-        type: '',
-        bounds: { bottom: 0, top: 0, left: 0, right: 0 }
-    };
-}

package/dist/lib/parsers/wms/parse-wms-layer-description.js

@@ -1,15 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWMSLayerDescription = void 0;
-const xml_1 = require("@loaders.gl/xml");
-/**
- * Parses a typed data structure from raw XML for `GetFeatureInfo` response
- * @note Error handlings is fairly weak
- */
-function parseWMSLayerDescription(text, options) {
-    const parsedXML = xml_1.XMLLoader.parseTextSync?.(text, options);
-    // TODO - implement parser
-    return parsedXML;
-}
-exports.parseWMSLayerDescription = parseWMSLayerDescription;