@loaders.gl/wms 3.3.0-alpha.9 → 3.3.0

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

@@ -0,0 +1,371 @@
+"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/lerc/lerc-types.d.ts

@@ -0,0 +1,30 @@
+/** Data returned by LERC loader */
+export type LERCData = {
+    /**	Width of decoded image */
+    width: number;
+    /**	Height of decoded image */
+    height: number;
+    /**	The type of pixels represented in the output */
+    pixelType: LercPixelType;
+    /**	[statistics_band1, statistics_band2, …] Each element is a statistics object representing min and max values  */
+    statistics: BandStats[];
+    /**	[band1, band2, …] Each band is a typed array of width * height * depthCount */
+    pixels: TypedArray[];
+    /**	Typed array with a size of width*height, or null if all pixels are valid */
+    mask: Uint8Array;
+    /**	Depth count  */
+    depthCount: number;
+    /**	array	[band1_mask, band2_mask, …] Each band is a Uint8Array of width * height * depthCount */
+    bandMasks?: Uint8Array[];
+};
+export type LercPixelType = 'S8' | 'U8' | 'S16' | 'U16' | 'S32' | 'U32' | 'F32' | 'F64';
+export interface BandStats {
+    minValue: number;
+    maxValue: number;
+    depthStats?: {
+        minValues: Float64Array;
+        maxValues: Float64Array;
+    };
+}
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+//# sourceMappingURL=lerc-types.d.ts.map

package/dist/lib/lerc/lerc-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lerc-types.d.ts","sourceRoot":"","sources":["../../../src/lib/lerc/lerc-types.ts"],"names":[],"mappings":"AAEA,mCAAmC;AACnC,MAAM,MAAM,QAAQ,GAAG;IACrB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,mDAAmD;IACnD,SAAS,EAAE,aAAa,CAAC;IACzB,mHAAmH;IACnH,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,kFAAkF;IAClF,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,+EAA+E;IAC/E,IAAI,EAAE,UAAU,CAAC;IACjB,mBAAmB;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,iGAAiG;IACjG,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AAExF,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE;QACX,SAAS,EAAE,YAAY,CAAC;QACxB,SAAS,EAAE,YAAY,CAAC;KACzB,CAAC;CACH;AAED,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,UAAU,GACV,iBAAiB,GACjB,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,YAAY,GACZ,YAAY,CAAC"}

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

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

package/dist/lib/wcs/parse-wcs.d.ts

@@ -0,0 +1,7 @@
+import type { WFSCapabilities } from './wcs-types';
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+export declare function parseWFSCapabilities(text: string, options: any): WFSCapabilities;
+//# sourceMappingURL=parse-wcs.d.ts.map

package/dist/lib/wcs/parse-wcs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-wcs.d.ts","sourceRoot":"","sources":["../../../src/lib/wcs/parse-wcs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAMjD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,KAAA,GAAG,eAAe,CAM3E"}

package/dist/lib/wcs/parse-wcs.js

@@ -0,0 +1,36 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWFSCapabilities = void 0;
+const xml_1 = require("@loaders.gl/xml");
+// GetCapabilities
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+function parseWFSCapabilities(text, options) {
+    // Remove namespaces in XML
+    options = { ...options, xml: { ...options?.xml, removeNSPrefix: true } };
+    const parsedXML = xml_1.XMLLoader.parseTextSync(text, options);
+    const xmlCapabilities = parsedXML.Capabilities || parsedXML;
+    return uncapitalizeKeys(xmlCapabilities);
+}
+exports.parseWFSCapabilities = parseWFSCapabilities;
+function uncapitalizeKeys(object) {
+    if (object && typeof object === 'object') {
+        const newObject = {};
+        for (const [key, value] of Object.entries(object)) {
+            newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+        }
+        return newObject;
+    }
+    return object;
+}
+/**
+ * Uncapitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+function uncapitalize(str) {
+    return typeof str === 'string' ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+}

package/dist/lib/wcs/wcs-types.d.ts

@@ -0,0 +1,73 @@
+/** All capabilities of a WFS service - response to a WFS `GetCapabilities` data structure extracted from XML */
+export type WFSCapabilities = {
+    serviceIdentification: {
+        title: string;
+        serviceTypeVersion: string;
+        serviceType: string;
+    };
+    serviceProvider: {
+        providerName: string;
+        providerSite: string;
+        serviceContact: {
+            individualName: string;
+            positionName: string;
+            contactInfo: {
+                address: {
+                    administrativeArea: string;
+                    city: string;
+                    country: string;
+                    deliveryPoint: string;
+                    electronicMailAddress: string;
+                    postalCode: string;
+                };
+                phone: {
+                    voice: string;
+                };
+            };
+        };
+    };
+    operationsMetadata: {
+        GetCapabilities: any;
+        GetFeatureInfo: any;
+        GetTile: any;
+    };
+    contents: {
+        layers: {
+            abstract: string;
+            identifier: string;
+            title: string;
+            formats: string[];
+            styles: {
+                identifier: string;
+                isDefault: string;
+                title: string;
+                abstract?: string;
+            }[];
+            bounds: {
+                left: number;
+                right: number;
+                bottom: number;
+                top: number;
+            };
+            tileMatrixSetLinks: {
+                tileMatrixSet: string;
+            }[];
+            tileMatrixSets: {
+                identifier: string;
+                matrixIds: {
+                    identifier: string;
+                    matrixHeight: number;
+                    matrixWidth: number;
+                    scaleDenominator: number;
+                    tileWidth: number;
+                    tileHeight: number;
+                    topLeftCorner: {
+                        lon: number;
+                        lat: number;
+                    };
+                }[];
+            };
+        }[];
+    };
+};
+//# sourceMappingURL=wcs-types.d.ts.map

package/dist/lib/wcs/wcs-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wcs-types.d.ts","sourceRoot":"","sources":["../../../src/lib/wcs/wcs-types.ts"],"names":[],"mappings":"AAEA,gHAAgH;AAChH,MAAM,MAAM,eAAe,GAAG;IAC5B,qBAAqB,EAAE;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,kBAAkB,EAAE,MAAM,CAAC;QAC3B,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IAEF,eAAe,EAAE;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,EAAE;YACd,cAAc,EAAE,MAAM,CAAC;YACvB,YAAY,EAAE,MAAM,CAAC;YACrB,WAAW,EAAE;gBACX,OAAO,EAAE;oBACP,kBAAkB,EAAE,MAAM,CAAC;oBAC3B,IAAI,EAAE,MAAM,CAAC;oBACb,OAAO,EAAE,MAAM,CAAC;oBAChB,aAAa,EAAE,MAAM,CAAC;oBACtB,qBAAqB,EAAE,MAAM,CAAC;oBAC9B,UAAU,EAAE,MAAM,CAAC;iBACpB,CAAC;gBACF,KAAK,EAAE;oBACL,KAAK,EAAE,MAAM,CAAC;iBACf,CAAC;aACH,CAAC;SACH,CAAC;KACH,CAAC;IAEF,kBAAkB,EAAE;QAClB,eAAe,EAAE,GAAG,CAAC;QACrB,cAAc,EAAE,GAAG,CAAC;QACpB,OAAO,EAAE,GAAG,CAAC;KACd,CAAC;IAEF,QAAQ,EAAE;QACR,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAC;YACjB,UAAU,EAAE,MAAM,CAAC;YACnB,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,EAAE,CAAC;YAClB,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE,MAAM,CAAC;gBAClB,KAAK,EAAE,MAAM,CAAC;gBACd,QAAQ,CAAC,EAAE,MAAM,CAAC;aACnB,EAAE,CAAC;YACJ,MAAM,EAAE;gBACN,IAAI,EAAE,MAAM,CAAC;gBACb,KAAK,EAAE,MAAM,CAAC;gBACd,MAAM,EAAE,MAAM,CAAC;gBACf,GAAG,EAAE,MAAM,CAAC;aACb,CAAC;YACF,kBAAkB,EAAE;gBAClB,aAAa,EAAE,MAAM,CAAC;aACvB,EAAE,CAAC;YACJ,cAAc,EAAE;gBACd,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE;oBACT,UAAU,EAAE,MAAM,CAAC;oBACnB,YAAY,EAAE,MAAM,CAAC;oBACrB,WAAW,EAAE,MAAM,CAAC;oBACpB,gBAAgB,EAAE,MAAM,CAAC;oBACzB,SAAS,EAAE,MAAM,CAAC;oBAClB,UAAU,EAAE,MAAM,CAAC;oBACnB,aAAa,EAAE;wBACb,GAAG,EAAE,MAAM,CAAC;wBACZ,GAAG,EAAE,MAAM,CAAC;qBACb,CAAC;iBACH,EAAE,CAAC;aACL,CAAC;SACH,EAAE,CAAC;KACL,CAAC;CACH,CAAC"}

package/dist/lib/wcs/wcs-types.js

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

package/dist/lib/wfs/parse-wfs.d.ts

@@ -0,0 +1,7 @@
+import type { WFSCapabilities } from './wfs-types';
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+export declare function parseWFSCapabilities(text: string, options: any): WFSCapabilities;
+//# sourceMappingURL=parse-wfs.d.ts.map

package/dist/lib/wfs/parse-wfs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-wfs.d.ts","sourceRoot":"","sources":["../../../src/lib/wfs/parse-wfs.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAMjD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,KAAA,GAAG,eAAe,CAM3E"}

package/dist/lib/wfs/parse-wfs.js

@@ -0,0 +1,36 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWFSCapabilities = void 0;
+const xml_1 = require("@loaders.gl/xml");
+// GetCapabilities
+/**
+ * Parses a typed data structure from raw XML for `GetCapabilities` response
+ * @note Error handlings is fairly weak
+ */
+function parseWFSCapabilities(text, options) {
+    // Remove namespaces in XML
+    options = { ...options, xml: { ...options?.xml, removeNSPrefix: true } };
+    const parsedXML = xml_1.XMLLoader.parseTextSync(text, options);
+    const xmlCapabilities = parsedXML.Capabilities || parsedXML;
+    return uncapitalizeKeys(xmlCapabilities);
+}
+exports.parseWFSCapabilities = parseWFSCapabilities;
+function uncapitalizeKeys(object) {
+    if (object && typeof object === 'object') {
+        const newObject = {};
+        for (const [key, value] of Object.entries(object)) {
+            newObject[uncapitalize(key)] = uncapitalizeKeys(value);
+        }
+        return newObject;
+    }
+    return object;
+}
+/**
+ * Uncapitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+function uncapitalize(str) {
+    return typeof str === 'string' ? str.charAt(0).toLowerCase() + str.slice(1) : str;
+}

package/dist/lib/wfs/wfs-types.d.ts

@@ -0,0 +1,73 @@
+/** All capabilities of a WFS service - response to a WFS `GetCapabilities` data structure extracted from XML */
+export type WFSCapabilities = {
+    serviceIdentification: {
+        title: string;
+        serviceTypeVersion: string;
+        serviceType: string;
+    };
+    serviceProvider: {
+        providerName: string;
+        providerSite: string;
+        serviceContact: {
+            individualName: string;
+            positionName: string;
+            contactInfo: {
+                address: {
+                    administrativeArea: string;
+                    city: string;
+                    country: string;
+                    deliveryPoint: string;
+                    electronicMailAddress: string;
+                    postalCode: string;
+                };
+                phone: {
+                    voice: string;
+                };
+            };
+        };
+    };
+    operationsMetadata: {
+        GetCapabilities: any;
+        GetFeatureInfo: any;
+        GetTile: any;
+    };
+    contents: {
+        layers: {
+            abstract: string;
+            identifier: string;
+            title: string;
+            formats: string[];
+            styles: {
+                identifier: string;
+                isDefault: string;
+                title: string;
+                abstract?: string;
+            }[];
+            bounds: {
+                left: number;
+                right: number;
+                bottom: number;
+                top: number;
+            };
+            tileMatrixSetLinks: {
+                tileMatrixSet: string;
+            }[];
+            tileMatrixSets: {
+                identifier: string;
+                matrixIds: {
+                    identifier: string;
+                    matrixHeight: number;
+                    matrixWidth: number;
+                    scaleDenominator: number;
+                    tileWidth: number;
+                    tileHeight: number;
+                    topLeftCorner: {
+                        lon: number;
+                        lat: number;
+                    };
+                }[];
+            };
+        }[];
+    };
+};
+//# sourceMappingURL=wfs-types.d.ts.map

package/dist/lib/wfs/wfs-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wfs-types.d.ts","sourceRoot":"","sources":["../../../src/lib/wfs/wfs-types.ts"],"names":[],"mappings":"AAEA,gHAAgH;AAChH,MAAM,MAAM,eAAe,GAAG;IAC1B,qBAAqB,EAAE;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,kBAAkB,EAAE,MAAM,CAAC;QAC3B,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IAEF,eAAe,EAAE;QACf,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,cAAc,EAAE;YACd,cAAc,EAAE,MAAM,CAAC;YACvB,YAAY,EAAE,MAAM,CAAC;YACrB,WAAW,EAAE;gBACX,OAAO,EAAE;oBACP,kBAAkB,EAAE,MAAM,CAAC;oBAC3B,IAAI,EAAE,MAAM,CAAC;oBACb,OAAO,EAAE,MAAM,CAAC;oBAChB,aAAa,EAAE,MAAM,CAAC;oBACtB,qBAAqB,EAAE,MAAM,CAAC;oBAC9B,UAAU,EAAE,MAAM,CAAC;iBACpB,CAAC;gBACF,KAAK,EAAE;oBACL,KAAK,EAAE,MAAM,CAAC;iBACf,CAAC;aACH,CAAC;SACH,CAAC;KACH,CAAC;IAEF,kBAAkB,EAAE;QAClB,eAAe,EAAE,GAAG,CAAC;QACrB,cAAc,EAAE,GAAG,CAAC;QACpB,OAAO,EAAE,GAAG,CAAC;KACd,CAAC;IAEF,QAAQ,EAAE;QACR,MAAM,EAAE;YACN,QAAQ,EAAE,MAAM,CAAC;YACjB,UAAU,EAAE,MAAM,CAAC;YACnB,KAAK,EAAE,MAAM,CAAC;YACd,OAAO,EAAE,MAAM,EAAE,CAAC;YAClB,MAAM,EAAE;gBACN,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE,MAAM,CAAC;gBAClB,KAAK,EAAE,MAAM,CAAC;gBACd,QAAQ,CAAC,EAAE,MAAM,CAAC;aACnB,EAAE,CAAC;YACJ,MAAM,EAAE;gBACN,IAAI,EAAE,MAAM,CAAC;gBACb,KAAK,EAAE,MAAM,CAAC;gBACd,MAAM,EAAE,MAAM,CAAC;gBACf,GAAG,EAAE,MAAM,CAAC;aACb,CAAC;YACF,kBAAkB,EAAE;gBAClB,aAAa,EAAE,MAAM,CAAC;aACvB,EAAE,CAAC;YACJ,cAAc,EAAE;gBACd,UAAU,EAAE,MAAM,CAAC;gBACnB,SAAS,EAAE;oBACT,UAAU,EAAE,MAAM,CAAC;oBACnB,YAAY,EAAE,MAAM,CAAC;oBACrB,WAAW,EAAE,MAAM,CAAC;oBACpB,gBAAgB,EAAE,MAAM,CAAC;oBACzB,SAAS,EAAE,MAAM,CAAC;oBAClB,UAAU,EAAE,MAAM,CAAC;oBACnB,aAAa,EAAE;wBACb,GAAG,EAAE,MAAM,CAAC;wBACZ,GAAG,EAAE,MAAM,CAAC;qBACb,CAAC;iBACH,EAAE,CAAC;aACL,CAAC;SACH,EAAE,CAAC;KACL,CAAC;CACH,CAAC"}

package/dist/lib/wfs/wfs-types.js

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