ogcopenapis 0.0.1 → 0.0.3

package/README.md

@@ -27,7 +27,7 @@ npm run build
 
 ## To test
 Some test have been added that run in nodejs. No browser test is available at the moment.
-To run the test make sure you are using nodejs > 18 as function fetch is required.
+Run uses isomorphic-fetch to provide fetch in node testing with jest.
 ```
 npm run test
 ```

package/lib/OgcOpenApiCrsTools.d.ts

@@ -0,0 +1,9 @@
+declare class OgcOpenApiCrsTools {
+    /**
+     *
+     * @param uriOrName
+     * @private
+     */
+    static getReferenceName(uriOrName: string): string;
+}
+export { OgcOpenApiCrsTools };

package/lib/OgcOpenApiCrsTools.js

@@ -0,0 +1,32 @@
+class OgcOpenApiCrsTools {
+    /**
+     *
+     * @param uriOrName
+     * @private
+     */
+    static getReferenceName(uriOrName) {
+        if (!uriOrName.startsWith('http')) {
+            return uriOrName;
+        }
+        const prefix = 'http://www.opengis.net/def/crs/';
+        if (uriOrName.startsWith(prefix)) {
+            const cleanCRS = uriOrName.substr(prefix.length);
+            const parts = cleanCRS.split('/');
+            if (parts.length === 3) {
+                const name = parts[0];
+                const version = parts[1];
+                const code = parts[2];
+                switch (name) {
+                    case 'EPSG':
+                        return name + ':' + code;
+                        break;
+                    case 'OGC':
+                        return 'CRS' + ':' + code.substr('CRS'.length);
+                        break;
+                }
+            }
+        }
+        return uriOrName;
+    }
+}
+export { OgcOpenApiCrsTools };

package/lib/OgcOpenApiFeatureStore.d.ts

@@ -0,0 +1,86 @@
+import { Store } from '@luciad/ria/model/store/Store';
+import { Cursor } from '@luciad/ria/model/Cursor';
+import { Feature } from '@luciad/ria/model/feature/Feature';
+import { Evented, Handle } from '@luciad/ria/util/Evented';
+import { Bounds } from '@luciad/ria/shape/Bounds';
+import { Codec, CodecDecodeOptions } from '@luciad/ria/model/codec/Codec';
+import { CoordinateReference } from '@luciad/ria/reference/CoordinateReference';
+interface OAPIFeatureStoreConstructorOptions {
+    dataUrl: string;
+    featureUrl?: string;
+    outputFormat: string;
+    useCrs84Bounds: boolean;
+    codec: Codec;
+    requestHeaders?: {
+        [key: string]: string;
+    };
+    customCrs: string;
+    extent?: {
+        spatial: {
+            bbox: any[];
+        };
+    };
+    reference: CoordinateReference;
+}
+interface OAPIFeatureStoreQueryOptions {
+    f?: string;
+    limit?: number;
+    offset?: number;
+    bbox?: number[];
+    "bbox-crs"?: string;
+    datetime?: string;
+    filter?: string;
+    "filter-crs"?: string;
+    "filter-lang"?: string;
+    crs?: string | any;
+    skipGeometry?: boolean;
+    properties?: string[];
+    sortby?: string[];
+    ident?: string;
+    name?: string;
+    q?: string[];
+    maxAllowableOffset?: number;
+    level?: string;
+    sector?: string;
+    milCode?: string;
+    localType?: string;
+    upperLimitDesc?: number;
+    upperLimitValue?: number;
+    upperLimitUnit?: string;
+    upperLimitCode?: string;
+    lowerLimitDesc?: string;
+    lowerLimitValue?: number;
+    lowerLimitUnit?: string;
+    lowerLimitCode?: string;
+    onshore?: boolean;
+    exclusion?: boolean;
+    wkhrCode?: string;
+    wkhrRemark?: string;
+}
+interface OgcOpenApiCodecDecodeOptions extends CodecDecodeOptions {
+    contentCrs?: string;
+    contentLength?: number;
+}
+export declare class OgcOpenApiFeatureStore implements Store, Evented {
+    private dataUrl;
+    private codec;
+    private eventedSupport;
+    private baseUrl;
+    private dataFormat;
+    private customCrs;
+    private bounds;
+    private requestHeaders;
+    private reference;
+    private outputFormat;
+    private useCrs84Bounds;
+    private featureUrl;
+    constructor(options: OAPIFeatureStoreConstructorOptions);
+    on(event: string, callback: any, context: any, options: any): Handle;
+    get(id: number | string, optionsInput?: any): Promise<Feature>;
+    query(receivedQuery?: OAPIFeatureStoreQueryOptions, options?: any): Cursor | Promise<Cursor>;
+    spatialQuery(bounds?: Bounds, receivedQuery?: OAPIFeatureStoreQueryOptions, options?: any): Promise<Cursor> | Cursor;
+    private static getCRS84BoundingBox;
+    private static cleanUrl;
+    private static dataFormatInQuery;
+}
+export { OgcOpenApiCodecDecodeOptions };

package/lib/OgcOpenApiFeatureStore.js

@@ -0,0 +1,206 @@
+import { EventedSupport } from '@luciad/ria/util/EventedSupport';
+import { createBounds } from '@luciad/ria/shape/ShapeFactory';
+import { getReference } from "@luciad/ria/reference/ReferenceProvider";
+import { createTransformation } from "@luciad/ria/transformation/TransformationFactory";
+export class OgcOpenApiFeatureStore {
+    constructor(options) {
+        // console.log(options);
+        this.useCrs84Bounds = typeof options.useCrs84Bounds !== "undefined" ? options.useCrs84Bounds : false;
+        this.dataUrl = options.dataUrl;
+        this.outputFormat = options.outputFormat;
+        const predictedFeatureUrl = this.dataUrl.replace(/\.[^/.]+$/, "");
+        this.featureUrl = options.featureUrl ? OgcOpenApiFeatureStore.cleanUrl(options.featureUrl) : OgcOpenApiFeatureStore.cleanUrl(predictedFeatureUrl);
+        this.baseUrl = OgcOpenApiFeatureStore.cleanUrl(this.dataUrl);
+        this.dataFormat = OgcOpenApiFeatureStore.dataFormatInQuery(this.dataUrl);
+        this.customCrs = options.customCrs;
+        this.codec = options.codec;
+        this.eventedSupport = new EventedSupport();
+        this.requestHeaders = options.requestHeaders ? options.requestHeaders : {};
+        this.reference = options.reference;
+        if (options.extent &&
+            options.extent.spatial &&
+            options.extent.spatial.bbox &&
+            options.extent.spatial.bbox.length > 0) {
+            const bbox = options.extent.spatial.bbox[0];
+            // console.log(options.extent.spatial);
+            this.bounds = createBounds(this.reference, [
+                bbox[0],
+                bbox[2] - bbox[0],
+                bbox[1],
+                bbox[3] - bbox[1],
+            ]);
+        }
+    }
+    on(event, callback, context, options) {
+        return this.eventedSupport.on(event, callback, context, options);
+    }
+    get(id, optionsInput) {
+        return new Promise((resolve) => {
+            const options = optionsInput ? Object.assign({}, optionsInput) : {};
+            options.query = (options.query ? options.query : {});
+            options.query.f = options.query.f ? options.query.f : this.dataFormat;
+            options.query.crs = options.query.crs ? options.query.crs : this.customCrs;
+            // Mod starta
+            const itemsAccept = typeof this.requestHeaders.accept !== 'undefined'
+                ? this.requestHeaders.accept.split(';')
+                : typeof this.requestHeaders.Accept !== 'undefined'
+                    ? this.requestHeaders.Accept.split(';')
+                    : [];
+            itemsAccept.push(this.outputFormat);
+            const accept = itemsAccept.join(';');
+            // Mod end
+            let request = this.featureUrl + id;
+            const simpleQuery = [];
+            if (options.query.f)
+                simpleQuery.push("f");
+            if (options.query.crs)
+                simpleQuery.push("crs");
+            if (simpleQuery.length > 0) {
+                const queryString = simpleQuery.map(k => "" + k + "=" + options.query[k]).join("&");
+                request += "?" + queryString;
+            }
+            const headers = Object.assign(Object.assign({}, this.requestHeaders), { Accept: accept });
+            fetch(request, {
+                method: 'GET',
+                headers,
+            }).then((response) => {
+                if (response.status === 200) {
+                    response.text().then((content) => {
+                        let contentType = response.headers.get('Content-Type');
+                        const contentCrs = response.headers.get('content-crs');
+                        const contentLengthStr = response.headers.get('Content-Length');
+                        const contentLength = Number(contentLengthStr);
+                        contentType = contentType ? contentType : 'text/plain';
+                        content = content
+                            .split('http://www.opengis.net/def/crs/OGC/1.3/CRS84')
+                            .join('urn:ogc:def:crs:OGC:1.3:CRS84');
+                        const codecOptions = {
+                            content, contentType, contentCrs, contentLength
+                        };
+                        const cursor = this.codec.decode(codecOptions);
+                        if (cursor.hasNext()) {
+                            const feaure = cursor.next();
+                            resolve(feaure);
+                        }
+                        else {
+                            resolve(null);
+                        }
+                    });
+                }
+            });
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    query(receivedQuery, options) {
+        return new Promise((resolve) => {
+            const query = receivedQuery ? Object.assign({}, receivedQuery) : {};
+            query.f = query.f ? query.f : this.dataFormat;
+            query.crs = query.crs ? query.crs : this.customCrs;
+            query.limit = query.limit ? query.limit : undefined;
+            let request = this.baseUrl;
+            // Mod starta
+            const itemsAccept = typeof this.requestHeaders.accept !== 'undefined'
+                ? this.requestHeaders.accept.split(';')
+                : typeof this.requestHeaders.Accept !== 'undefined'
+                    ? this.requestHeaders.Accept.split(';')
+                    : [];
+            itemsAccept.push(this.outputFormat);
+            const accept = itemsAccept.join(';');
+            // Mod end
+            const allKeys = Object.keys(query);
+            if (allKeys.length > 0) {
+                const filteredKeys = allKeys.filter(e => (typeof query[e] !== "undefined" && query[e] !== null));
+                const indexOfFormat = filteredKeys.indexOf("f");
+                if (indexOfFormat > -1) {
+                    filteredKeys.splice(indexOfFormat, 1);
+                    filteredKeys.unshift("f");
+                }
+                const queryString = filteredKeys.map(k => "" + k + "=" + query[k]).join("&");
+                request += "?" + queryString;
+            }
+            const headers = Object.assign(Object.assign({}, this.requestHeaders), { Accept: accept });
+            // const headers = { ...this.requestHeaders };
+            fetch(request, {
+                method: 'GET',
+                headers,
+            }).then((response) => {
+                if (response.status === 200) {
+                    response.text().then((content) => {
+                        let contentType = response.headers.get('Content-Type');
+                        const contentCrs = response.headers.get('content-crs');
+                        const contentLengthStr = response.headers.get('Content-Length');
+                        const contentLength = Number(contentLengthStr);
+                        contentType = contentType ? contentType : 'text/plain';
+                        content = content
+                            .split('srsName="http://www.opengis.net/def/crs/OGC/1.3/CRS84"')
+                            .join('srsName="urn:ogc:def:crs:OGC:1.3:CRS84"');
+                        const codecOptions = {
+                            content, contentType, contentCrs, contentLength
+                        };
+                        const cursor = this.codec.decode(codecOptions);
+                        resolve(cursor);
+                    });
+                }
+            });
+        });
+    }
+    spatialQuery(bounds, receivedQuery, options) {
+        const query = (receivedQuery ? Object.assign({}, receivedQuery) : {});
+        delete query.bbox;
+        query.limit = query.limit ? query.limit : undefined;
+        if (bounds) {
+            if (this.useCrs84Bounds) {
+                const crs84Bounds = OgcOpenApiFeatureStore.getCRS84BoundingBox(bounds);
+                query.bbox = query.bbox
+                    ? query.bbox
+                    : [
+                        crs84Bounds.x,
+                        crs84Bounds.y,
+                        crs84Bounds.x + crs84Bounds.width,
+                        crs84Bounds.y + crs84Bounds.height,
+                    ];
+            }
+            else {
+                query.bbox = query.bbox
+                    ? query.bbox
+                    : [
+                        bounds.x,
+                        bounds.y,
+                        bounds.x + bounds.width,
+                        bounds.y + bounds.height,
+                    ];
+                if (this.customCrs) {
+                    query["bbox-crs"] = this.customCrs;
+                }
+            }
+        }
+        return this.query(query, options);
+    }
+    static getCRS84BoundingBox(shape) {
+        const WGS84 = getReference("CRS:84");
+        const bounds = shape.bounds;
+        const toWgs84 = createTransformation(bounds.reference, WGS84);
+        const newBounds = toWgs84.transformBounds(bounds);
+        return newBounds;
+    }
+    static cleanUrl(dataUrl) {
+        const parts = dataUrl.split('?');
+        const cleanUrl = parts[0].endsWith('/') ? parts[0] : parts[0] + '/';
+        return cleanUrl;
+    }
+    static dataFormatInQuery(dataUrl) {
+        let format;
+        const parts = dataUrl.split('?');
+        if (parts.length > 1) {
+            const query = parts[1];
+            const qs = query.split('&');
+            for (const q of qs) {
+                if (q.startsWith('f=')) {
+                    format = q.substr(2);
+                    return format;
+                }
+            }
+        }
+        return format;
+    }
+}

package/lib/OgcOpenApiFetchTools.d.ts

@@ -0,0 +1,31 @@
+interface ExtFetchOptions {
+    originalUrl: string;
+    complete?: (url: string) => string;
+    proxify?: (url: string) => {
+        url: string;
+        fetchOptions: RequestInit;
+    };
+}
+export interface FetchServerOptions {
+    proxy: (url: string, fetchOptions: any) => {
+        fetchOptions: any;
+        url: string;
+    };
+    hostname: string;
+    complete: (url: string) => string;
+}
+declare class OgcOpenApiFetchTools {
+    static createFetchOptions(options: ExtFetchOptions): {
+        hostname: string;
+        complete: (url: string) => string;
+        proxy: (url: string, fetchOptions: any) => {
+            url: string;
+            fetchOptions: any;
+        };
+    };
+    static fetch(input: string, options: RequestInit, serverOptions: FetchServerOptions): Promise<Response>;
+    static addHostURL(url: string, HostUrl?: string): string;
+    static cleanUrl(inputUrl: string): string;
+    static getHostURL(fullUrl: string): string;
+}
+export { OgcOpenApiFetchTools };

package/lib/OgcOpenApiFetchTools.js

@@ -0,0 +1,46 @@
+class OgcOpenApiFetchTools {
+    static createFetchOptions(options) {
+        const hostname = this.getHostURL(options.originalUrl);
+        return {
+            hostname: hostname,
+            complete: typeof options.complete === "function" ? options.complete : (url) => {
+                return this.addHostURL(url, hostname);
+            },
+            proxy: typeof options.proxify === "function" ? options.proxify : (url, fetchOptions) => ({
+                url: url,
+                fetchOptions: fetchOptions
+            })
+        };
+    }
+    static fetch(input, options, serverOptions) {
+        const fullUrl = serverOptions.complete(input);
+        const result = serverOptions.proxy(fullUrl, options);
+        return fetch(result.url, result.fetchOptions);
+    }
+    static addHostURL(url, HostUrl) {
+        const hostUrl = HostUrl ? HostUrl : "";
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+            return url;
+        }
+        else {
+            if (url.startsWith("/"))
+                return hostUrl + url;
+            if (url.startsWith("./"))
+                return hostUrl + url.substring(1);
+        }
+        return hostUrl + "/" + url;
+    }
+    static cleanUrl(inputUrl) {
+        const url = inputUrl.split("?")[0].replace(/\/?$/, '/');
+        return url;
+    }
+    static getHostURL(fullUrl) {
+        if (!fullUrl.startsWith("http"))
+            return "";
+        const pathArray = fullUrl.split('/');
+        const protocol = pathArray[0];
+        const host = pathArray[2];
+        return protocol + '//' + host;
+    }
+}
+export { OgcOpenApiFetchTools };

package/lib/OgcOpenApiGetCapabilities.d.ts

@@ -0,0 +1,114 @@
+import { FetchServerOptions } from "./OgcOpenApiFetchTools";
+type RequestHeaders = {
+    [headerName: string]: string;
+} | null;
+export interface LinkType {
+    rel: string;
+    type: string;
+    title: string;
+    href: string;
+}
+interface TileMatrix {
+    id: string;
+    scaleDenominator: number;
+    cellSize: number;
+    cornerOfOrigin: string;
+    pointOfOrigin: number[];
+    matrixWidth: number;
+    matrixHeight: number;
+    tileWidth: number;
+    tileHeight: number;
+    variableMatrixWidths: {
+        coalesce: number;
+        minTileRow: number;
+        maxTileRow: number;
+    }[];
+}
+export interface TileSetData {
+    id: string;
+    title: string;
+    uri: string;
+    crs: string;
+    orderedAxes: string[];
+    tileMatrices: TileMatrix[];
+    boundingBox: {
+        lowerLeft: number[];
+        upperRight: number[];
+    };
+}
+export interface TileSetMeta {
+    id: string;
+    title: string;
+    links: LinkType[];
+}
+export interface OgcOpenApiCapabilitiesObject {
+    name: string;
+    collections: OgcOpenApiCapabilitiesCollection[];
+    version: string;
+    service: string;
+    info: any;
+    crs?: any[];
+    baseUrl: string;
+    serverOptions: FetchServerOptions;
+}
+export interface OgcOpenApiCapabilitiesCollection {
+    id: string;
+    name: string;
+    title: string;
+    defaultReference: string;
+    outputFormats: string[];
+    description: string;
+    keywords: string[];
+    links: OgcOpenApiCapabilitiesCollectionServiceLinkType[];
+    extent: any;
+    crs?: any;
+    storageCrs?: any;
+}
+export interface OgcOpenApiCapabilitiesCollectionServiceLinkType {
+    rel: string;
+    type: string;
+    title: string;
+    href: string;
+}
+export declare enum CollectionLinkType {
+    Items = "items",
+    Styles = "styles",
+    Map = "map",
+    Tiles = "tiles"
+}
+export interface OgcOpenApiGetCapabilitiesFromURL {
+    filterCollectionsByLinkType?: CollectionLinkType;
+    credentials?: boolean;
+    requestHeaders?: {
+        [headerName: string]: string;
+    } | null;
+    proxify?: (url: string) => {
+        url: string;
+        fetchOptions: RequestInit;
+    };
+}
+export declare class OgcOpenApiGetCapabilities {
+    static fromURL(inputRequest: string, options?: OgcOpenApiGetCapabilitiesFromURL): Promise<OgcOpenApiCapabilitiesObject>;
+    private static fetchLinkContentAsJSON;
+    static filterCollectionLinks(links: OgcOpenApiCapabilitiesCollectionServiceLinkType[], linkType: CollectionLinkType): OgcOpenApiCapabilitiesCollectionServiceLinkType[];
+    static getDataLink(currentLayer: OgcOpenApiCapabilitiesCollection, preferedFormat: string): string;
+    private static detectTypeFormat;
+    static fetchTileSetsInFull(capabilities: OgcOpenApiCapabilitiesObject | null, options?: {
+        credentials?: boolean;
+        requestHeaders?: RequestHeaders;
+    }): Promise<TileSetData[]>;
+    static getQuadTreeCompatibleLevelOffset(tileMatrixSet: TileSetData): number;
+    static fetchTileSets(capabilities: OgcOpenApiCapabilitiesObject | null, options?: {
+        credentials?: boolean;
+        requestHeaders?: RequestHeaders;
+    }): Promise<TileSetMeta[]>;
+    static getTilesLink(capabilities: OgcOpenApiCapabilitiesObject | null, currentCollection: OgcOpenApiCapabilitiesCollection, tileMatrixId: string, options?: {
+        credentials?: boolean;
+        requestHeaders?: RequestHeaders;
+    }): Promise<LinkType[]>;
+    static fetchTileset(capabilities: OgcOpenApiCapabilitiesObject | null, tileset: TileSetMeta, options?: {
+        credentials?: boolean;
+        requestHeaders?: RequestHeaders;
+    }): Promise<TileSetData>;
+}
+export {};

package/lib/OgcOpenApiGetCapabilities.js

@@ -0,0 +1,276 @@
+import { OgcOpenApiFetchTools } from "./OgcOpenApiFetchTools";
+const SCALE_DENOMINATOR_TOLERANCE = 1e-8;
+export var CollectionLinkType;
+(function (CollectionLinkType) {
+    CollectionLinkType["Items"] = "items";
+    CollectionLinkType["Styles"] = "styles";
+    CollectionLinkType["Map"] = "map";
+    CollectionLinkType["Tiles"] = "tiles";
+})(CollectionLinkType || (CollectionLinkType = {}));
+const CollectionLinkTypeAlternatives = {
+    [CollectionLinkType.Items]: ["items", "item"],
+    [CollectionLinkType.Styles]: ["http://www.opengis.net/def/rel/ogc/1.0/styles", "styles"],
+    [CollectionLinkType.Map]: ["http://www.opengis.net/def/rel/ogc/1.0/map", "map"],
+    [CollectionLinkType.Tiles]: ["http://www.opengis.net/def/rel/ogc/1.0/tilesets-map", "tilesets-map"],
+};
+export class OgcOpenApiGetCapabilities {
+    static fromURL(inputRequest, options) {
+        return new Promise((resolve, reject) => {
+            const baseUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
+            const requestUrl = OgcOpenApiFetchTools.cleanUrl(inputRequest);
+            const serverOptions = OgcOpenApiFetchTools.createFetchOptions({ originalUrl: requestUrl, proxify: options === null || options === void 0 ? void 0 : options.proxify });
+            OgcOpenApiFetchTools.fetch(requestUrl, {
+                method: 'GET',
+                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
+                headers: options ? options.requestHeaders : {},
+            }, serverOptions).then((response) => {
+                if (response.status === 200) {
+                    response.json().then((jsonObject) => {
+                        if (!jsonObject.links) {
+                            reject("Invalid format: (property 'links' is missing)");
+                            return;
+                        }
+                        let linkToData = jsonObject.links.find((link) => link.rel === 'data' && link.type === 'application/json');
+                        if (!linkToData) {
+                            linkToData = jsonObject.links.find((link) => link.rel === 'data');
+                        }
+                        const linkToApi = jsonObject.links.find((link) => {
+                            return ((link.rel === 'service-desc' || link.rel === 'service') &&
+                                link.type.indexOf('openapi+json') > -1);
+                        });
+                        const promiseArray = [];
+                        if (linkToData) {
+                            const collectionsPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(linkToData, { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
+                            promiseArray.push(collectionsPromise);
+                            if (linkToApi) {
+                                const apiPromise = OgcOpenApiGetCapabilities.fetchLinkContentAsJSON(linkToApi, { credentials: options.credentials, requestHeaders: options.requestHeaders }, serverOptions);
+                                promiseArray.push(apiPromise);
+                            }
+                            Promise.all(promiseArray).then((responses) => {
+                                const responseDataLink = responses[0];
+                                const responseOpenApi = responses.length >= 1 ? responses[1] : undefined;
+                                const crsArray = typeof responseDataLink.crs !== "undefined" ? { crs: responseDataLink.crs } : {};
+                                const foundCollections = responseDataLink.collections.filter(c => options && options.filterCollectionsByLinkType ?
+                                    OgcOpenApiGetCapabilities.filterCollectionLinks(c.links, options.filterCollectionsByLinkType).length > 0 : true)
+                                    .map((collection) => {
+                                    const name = typeof collection.id !== 'undefined'
+                                        ? collection.id
+                                        : collection.name;
+                                    const collectionCrsObject = {};
+                                    if (typeof collection.crs !== "undefined")
+                                        collectionCrsObject.crs = collection.crs;
+                                    if (typeof collection.storageCrs !== "undefined")
+                                        collectionCrsObject.storageCrs = collection.storageCrs;
+                                    const layer = Object.assign({ description: collection.description, id: name, name, title: collection.title, keywords: collection.keywords
+                                            ? collection.keywords
+                                            : [], defaultReference: 'CRS:84', links: collection.links, outputFormats: options.filterCollectionsByLinkType ?
+                                            this.filterCollectionLinks(collection.links, options.filterCollectionsByLinkType).map(link => this.detectTypeFormat(link)) :
+                                            collection.links.map(link => this.detectTypeFormat(link)), extent: collection.extent }, collectionCrsObject);
+                                    return layer;
+                                });
+                                // console.log(featureTypes);
+                                const o = Object.assign(Object.assign({ name: '', collections: foundCollections, version: responseOpenApi ? responseOpenApi.openapi : '', service: '', info: responseOpenApi ? responseOpenApi.info : {} }, crsArray), { serverOptions: serverOptions, baseUrl });
+                                resolve(o);
+                            });
+                        }
+                        else {
+                            reject("Invalid format: (property 'links' contains no links with rel=data");
+                        }
+                    }, () => {
+                        reject("Not JSON");
+                    });
+                }
+                else {
+                    reject(response.status);
+                }
+            }, (err) => {
+                reject(err);
+            });
+        });
+    }
+    static fetchLinkContentAsJSON(link, options, serverOptions) {
+        return new Promise((resolve) => {
+            OgcOpenApiFetchTools.fetch(link.href, { method: "GET", credentials: options.credentials ? "same-origin" : "omit", headers: options.requestHeaders }, serverOptions).then((result) => {
+                if (result.status === 200) {
+                    result.json().then((json) => resolve(json));
+                }
+                else {
+                    resolve(undefined);
+                }
+            }, () => {
+                resolve(undefined);
+            });
+        });
+    }
+    static filterCollectionLinks(links, linkType) {
+        switch (linkType) {
+            case CollectionLinkType.Items:
+            case CollectionLinkType.Map:
+            case CollectionLinkType.Styles:
+            case CollectionLinkType.Tiles:
+                return links.filter((link) => CollectionLinkTypeAlternatives[linkType].some(e => e === link.rel));
+            default:
+                return [];
+        }
+    }
+    static getDataLink(currentLayer, preferedFormat) {
+        const dataLink = OgcOpenApiGetCapabilities.filterCollectionLinks(currentLayer.links, CollectionLinkType.Items).find((link) => link.type === preferedFormat);
+        return dataLink ? dataLink.href : '';
+    }
+    static detectTypeFormat(link) {
+        if (link.type)
+            return link.type;
+        let rel = null;
+        for (let key in CollectionLinkTypeAlternatives) {
+            if (CollectionLinkTypeAlternatives.hasOwnProperty(key)) {
+                CollectionLinkTypeAlternatives[key].some(e => e === link.rel);
+                rel = key;
+                break;
+            }
+        }
+        if (rel) {
+            if (CollectionLinkType.Map)
+                return "image/png";
+        }
+        return "application/json";
+    }
+    static fetchTileSetsInFull(capabilities, options) {
+        return new Promise((resolve, reject) => {
+            this.fetchTileSets(capabilities, options).then((tileSetMetaArray) => {
+                const promises = tileSetMetaArray.map(tml => this.fetchTileset(capabilities, tml, options));
+                Promise.all(promises).then((arr) => {
+                    resolve(arr);
+                });
+            });
+        });
+    }
+    static getQuadTreeCompatibleLevelOffset(tileMatrixSet) {
+        const levels = tileMatrixSet.tileMatrices;
+        const reference = levels[levels.length - 1];
+        for (let level = levels.length - 2; level >= 0; level--) {
+            const current = levels[level];
+            // tslint:disable-next-line:no-bitwise
+            const multiplier = 1 << (levels.length - level - 1);
+            const errorMargin = current.scaleDenominator * SCALE_DENOMINATOR_TOLERANCE;
+            if (Math.abs(current.scaleDenominator - reference.scaleDenominator * multiplier) > errorMargin) {
+                return level + 1;
+            }
+            if (current.pointOfOrigin[0] !== reference.pointOfOrigin[0]) {
+                return level + 1;
+            }
+            if (current.tileWidth !== reference.tileWidth || current.tileHeight !== reference.tileHeight) {
+                return level + 1;
+            }
+            if (typeof current.variableMatrixWidths !== "undefined") {
+                return level + 1;
+            }
+            if (current.matrixWidth !== (reference.matrixWidth / multiplier) || current.matrixHeight !== (reference.matrixHeight / multiplier)) {
+                return level + 1;
+            }
+        }
+        return 0;
+    }
+    static fetchTileSets(capabilities, options) {
+        return new Promise((resolve, reject) => {
+            if (capabilities === null)
+                reject();
+            const url = capabilities.baseUrl + "tileMatrixSets";
+            OgcOpenApiFetchTools.fetch(url, {
+                method: "GET",
+                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
+                headers: (options === null || options === void 0 ? void 0 : options.requestHeaders) ? options.requestHeaders : {}
+            }, capabilities.serverOptions).then(result => {
+                if (result.status === 200) {
+                    result.json().then((data) => {
+                        if (data.tileMatrixSets) {
+                            resolve(data.tileMatrixSets);
+                        }
+                        else {
+                            reject({ error: true, message: "tileMatrixSets not defined" });
+                        }
+                    }, () => {
+                        reject({ error: true, message: "Not JSON data" });
+                    });
+                }
+                else {
+                    reject({ error: true, message: "Invalid response: " + result.status });
+                }
+            }, (err) => {
+                reject({ error: true, message: err.message });
+            });
+        });
+    }
+    static getTilesLink(capabilities, currentCollection, tileMatrixId, options) {
+        return new Promise((resolve, reject) => {
+            if (capabilities === null)
+                reject();
+            const dataLinks = OgcOpenApiGetCapabilities.filterCollectionLinks(currentCollection.links, CollectionLinkType.Tiles);
+            const link = dataLinks.find((link) => link.type === "application/json");
+            const href = link ? link.href : dataLinks.length > 0 ? dataLinks[0].href : '';
+            const tileInfoUrl = OgcOpenApiFetchTools.cleanUrl(href) + tileMatrixId;
+            OgcOpenApiFetchTools.fetch(tileInfoUrl, {
+                method: "GET",
+                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
+                headers: (options === null || options === void 0 ? void 0 : options.requestHeaders) ? options === null || options === void 0 ? void 0 : options.requestHeaders : {}
+            }, capabilities.serverOptions).then(result => {
+                if (result.status === 200) {
+                    result.json().then((data) => {
+                        if (data.links.length > 0) {
+                            const links = data.links.filter(l => l.rel === "item" || l.rel === "items").map(a => (Object.assign(Object.assign({}, a), { href: capabilities.serverOptions.complete(a.href) })));
+                            if (links) {
+                                resolve(links);
+                            }
+                            else {
+                                reject({ error: true, message: "Invalid" });
+                            }
+                        }
+                        else {
+                            reject({ error: true, message: "Invalid" });
+                        }
+                    }, () => {
+                        reject({ error: true, message: "Not JSON data" });
+                    });
+                }
+                else {
+                    reject({ error: true, message: "Invalid response: " + result.status });
+                }
+            }, (err) => {
+                reject({ error: true, message: err.message });
+            });
+        });
+    }
+    static fetchTileset(capabilities, tileset, options) {
+        return new Promise((resolve, reject) => {
+            if (capabilities === null) {
+                reject();
+                return;
+            }
+            let jsonLink = tileset.links.find(l => l.type ? l.type === "application/json" : false);
+            jsonLink = jsonLink ? jsonLink : tileset.links[0];
+            const href = OgcOpenApiFetchTools.cleanUrl(jsonLink.href);
+            OgcOpenApiFetchTools.fetch(href, {
+                method: "GET",
+                credentials: (options === null || options === void 0 ? void 0 : options.credentials) ? "same-origin" : "omit",
+                headers: options ? options.requestHeaders : {}
+            }, capabilities.serverOptions).then(result => {
+                if (result.status === 200) {
+                    result.json().then((data) => {
+                        if (typeof data.id !== "undefined" && data.tileMatrices && data.crs) {
+                            resolve(data);
+                        }
+                        else {
+                            reject({ error: true, message: "TileSet has invalid data" });
+                        }
+                    }, () => {
+                        reject({ error: true, message: "Not JSON data" });
+                    });
+                }
+                else {
+                    reject({ error: true, message: "Invalid response: " + result.status });
+                }
+            }, (err) => {
+                reject({ error: true, message: err.message });
+            });
+        });
+    }
+}

package/lib/OgcOpenApiGetCollectionTiles.d.ts

@@ -0,0 +1,7 @@
+import { OgcOpenApiCapabilitiesCollection, OgcOpenApiCapabilitiesObject } from "./OgcOpenApiGetCapabilities";
+declare class OgcOpenApiGetCollectionTiles {
+    private collection;
+    private capabilities;
+    constructor(collection: OgcOpenApiCapabilitiesCollection, capabilities: OgcOpenApiCapabilitiesObject);
+}
+export { OgcOpenApiGetCollectionTiles };

package/lib/OgcOpenApiGetCollectionTiles.js

@@ -0,0 +1,7 @@
+class OgcOpenApiGetCollectionTiles {
+    constructor(collection, capabilities) {
+        this.collection = collection;
+        this.capabilities = capabilities;
+    }
+}
+export { OgcOpenApiGetCollectionTiles };

package/lib/OgcOpenApiMapsModel.d.ts

@@ -0,0 +1,32 @@
+import { RasterDataType } from "@luciad/ria/model/tileset/RasterDataType";
+import { RasterSamplingMode } from "@luciad/ria/model/tileset/RasterSamplingMode";
+import { WMSTileSetModel } from "@luciad/ria/model/tileset/WMSTileSetModel";
+import { TileCoordinate } from "@luciad/ria/model/tileset/TileCoordinate";
+interface OgcOpenApiMapsModelConstructorOptions {
+    crs: string;
+    baseURL: string;
+    collection: string;
+    dataType?: RasterDataType;
+    samplingMode?: RasterSamplingMode;
+    requestHeaders?: {
+        [p: string]: string;
+    };
+    format?: string;
+    reverseAxis?: boolean;
+    datetime?: string;
+    subset?: string[];
+    transparent?: boolean;
+    bgcolor?: string;
+}
+declare class OgcOpenApiMapsModel extends WMSTileSetModel {
+    private format;
+    private crs;
+    private reverseAxis;
+    private datetime;
+    private subset;
+    private bgcolor;
+    constructor(o: OgcOpenApiMapsModelConstructorOptions);
+    getTileURL(baseURL: string, tile: TileCoordinate): string | null;
+    private static createURLParameters;
+}
+export { OgcOpenApiMapsModel };

package/lib/OgcOpenApiMapsModel.js

@@ -0,0 +1,69 @@
+import { WMSTileSetModel } from "@luciad/ria/model/tileset/WMSTileSetModel";
+import { OgcOpenApiCrsTools } from "./OgcOpenApiCrsTools";
+import { getReference } from "@luciad/ria/reference/ReferenceProvider";
+class OgcOpenApiMapsModel extends WMSTileSetModel {
+    constructor(o) {
+        const referenceName = OgcOpenApiCrsTools.getReferenceName(o.crs);
+        const reference = getReference(referenceName);
+        super({
+            reference,
+            getMapRoot: o.baseURL,
+            layers: [o.collection],
+            dataType: o.dataType,
+            samplingMode: o.samplingMode,
+            requestHeaders: o.requestHeaders
+        });
+        this.crs = o.crs;
+        this.format = o.format;
+        this.reverseAxis = o.reverseAxis;
+        this.datetime = o.datetime;
+        this.subset = o.subset;
+        this.transparent = typeof o.transparent !== "undefined" ? o.transparent : true;
+        this.bgcolor = o.bgcolor;
+        this.modelDescriptor = {
+            source: o.baseURL,
+            name: o.collection,
+            description: "OGC Open API Maps",
+            type: super.dataType
+        };
+    }
+    getTileURL(baseURL, tile) {
+        let aURL = super.getTileURL(baseURL, tile);
+        if (aURL) {
+            const parts = aURL.split("?");
+            const queryString = parts.length > 1 ? parts[1] : "";
+            const url = parts[0];
+            const urlParams = new URLSearchParams(queryString);
+            const bbox = urlParams.get('BBOX');
+            const urlParameters = {
+                bbox: bbox,
+                "bbox-crs": this.crs,
+                crs: this.crs,
+                f: this.format,
+                datetime: this.datetime,
+                subset: this.subset,
+                transparent: this.transparent,
+                bgcolor: this.transparent ? undefined : this.bgcolor
+            };
+            const query = OgcOpenApiMapsModel.createURLParameters(urlParameters);
+            const transformedUrl = url + "?" + query;
+            return transformedUrl;
+        }
+        else {
+            return aURL;
+        }
+    }
+    static createURLParameters(obj) {
+        let str = Object.keys(obj).filter(k => obj[k] !== undefined).map(function (key) {
+            if (Array.isArray(obj[key])) {
+                return key + '=' + obj[key].join(",");
+            }
+            if (typeof obj[key] == "boolean") {
+                return key + '=' + (obj[key] ? "true" : "false");
+            }
+            return key + '=' + obj[key];
+        }).join('&');
+        return str;
+    }
+}
+export { OgcOpenApiMapsModel };

package/lib/OgcOpenApiTilesModel.d.ts

@@ -0,0 +1,28 @@
+import { UrlTileSetModel } from "@luciad/ria/model/tileset/UrlTileSetModel";
+import { RasterDataType } from "@luciad/ria/model/tileset/RasterDataType";
+import { RasterSamplingMode } from "@luciad/ria/model/tileset/RasterSamplingMode";
+import { TileCoordinate } from "@luciad/ria/model/tileset/TileCoordinate";
+import { TileSetData } from "./OgcOpenApiGetCapabilities";
+export interface OgcOpenApiTilesModelOptions {
+    tileMatrix: TileSetData;
+    baseURL: string;
+    collection: string;
+    dataType?: RasterDataType;
+    samplingMode?: RasterSamplingMode;
+    requestHeaders?: {
+        [p: string]: string;
+    };
+    transparent?: boolean;
+    bgcolor?: string;
+}
+export declare class OgcOpenApiTilesModel extends UrlTileSetModel {
+    private tileMatrix;
+    private invertY;
+    private plevel0Rows;
+    private transparent;
+    private bgcolor;
+    constructor(options: OgcOpenApiTilesModelOptions);
+    getTileURL(baseURL: string, tile: TileCoordinate): string | null;
+    debugAsImage(tileCorrected: TileCoordinate): string;
+    private static createURLParameters;
+}

package/lib/OgcOpenApiTilesModel.js

@@ -0,0 +1,121 @@
+import { UrlTileSetModel } from "@luciad/ria/model/tileset/UrlTileSetModel";
+import { getReference } from "@luciad/ria/reference/ReferenceProvider";
+import { createBounds } from "@luciad/ria/shape/ShapeFactory";
+import { OgcOpenApiCrsTools } from "./OgcOpenApiCrsTools";
+export class OgcOpenApiTilesModel extends UrlTileSetModel {
+    constructor(options) {
+        const crsName = OgcOpenApiCrsTools.getReferenceName(options.tileMatrix.crs);
+        const reference = getReference(crsName);
+        const levelCount = options.tileMatrix.tileMatrices.filter((t) => Number(t.id) > -1).length;
+        let invertY = true;
+        let axisX = 0;
+        let axisY = 1;
+        const orderedAxes0 = options.tileMatrix.orderedAxes[0].toUpperCase();
+        if (orderedAxes0 === "LAT" || orderedAxes0 === "N" || orderedAxes0 === "S") {
+            axisX = 1;
+            axisY = 0;
+        }
+        //const tm0 = options.tileMatrix.tileMatrices.find(t=>Number(t.id)===0);
+        const tm0 = options.tileMatrix.tileMatrices[0];
+        const calculated = {
+            tileWidth: 256,
+            tileHeight: 256,
+        };
+        let bounds;
+        if (options.tileMatrix.boundingBox && options.tileMatrix.boundingBox.lowerLeft && options.tileMatrix.boundingBox.upperRight) {
+            bounds = createBounds(reference, [
+                options.tileMatrix.boundingBox.lowerLeft[1], options.tileMatrix.boundingBox.upperRight[1] - options.tileMatrix.boundingBox.lowerLeft[1],
+                options.tileMatrix.boundingBox.lowerLeft[0], options.tileMatrix.boundingBox.upperRight[0] - options.tileMatrix.boundingBox.lowerLeft[0],
+            ]);
+        }
+        let level0Columns = 1;
+        let level0Rows = 1;
+        let tileHeight = 256;
+        let tileWidth = 256;
+        if (tm0) {
+            const cornerOfOrigin = tm0.cornerOfOrigin ? tm0.cornerOfOrigin : "TOPLEFT";
+            calculated.tileWidth = tm0.tileWidth;
+            calculated.tileHeight = tm0.tileHeight;
+            level0Rows = tm0.matrixHeight;
+            level0Columns = tm0.matrixWidth;
+            tileHeight = tm0.tileHeight;
+            tileWidth = tm0.tileHeight;
+            bounds = bounds ? bounds : reference.bounds;
+            if (cornerOfOrigin.toUpperCase() === "TOPLEFT") {
+                invertY = true;
+                // bounds = bounds ? bounds : createBounds(reference, [tm0.pointOfOrigin[axisX],tm0.matrixWidth, tm0.pointOfOrigin[axisY]-tm0.matrixHeight, tm0.matrixHeight])
+            }
+            else {
+                invertY = false;
+                //bounds = bounds ? bounds : createBounds(reference, [tm0.pointOfOrigin[axisX],tm0.matrixWidth, tm0.pointOfOrigin[axisY], tm0.matrixHeight])
+            }
+        }
+        const o = {
+            baseURL: options.baseURL,
+            reference: reference,
+            bounds: bounds,
+            tileHeight,
+            tileWidth,
+            levelCount: levelCount,
+            level0Columns,
+            level0Rows,
+            dataType: options.dataType,
+            samplingMode: options.samplingMode,
+            requestHeaders: options.requestHeaders ? options.requestHeaders : {},
+        };
+        super(o);
+        this.plevel0Rows = level0Rows;
+        this.transparent = typeof options.transparent !== "undefined" ? options.transparent : true;
+        this.bgcolor = options.bgcolor;
+        this.invertY = invertY;
+        this.tileMatrix = options.tileMatrix;
+        this.modelDescriptor = {
+            source: options.baseURL,
+            name: options.collection,
+            description: "OGC Open API Tiles",
+            type: super.dataType
+        };
+    }
+    getTileURL(baseURL, tile) {
+        const tileCorrected = Object.assign({}, tile);
+        //  return this.debugAsImage(tileCorrected)
+        const maxY = this.plevel0Rows * Math.pow(2, tile.level) - 1;
+        tileCorrected.y = this.invertY ? maxY - tile.y : tile.y;
+        const zoomLevel = this.tileMatrix.tileMatrices.find(t => Number(t.id) === tile.level);
+        const level = zoomLevel ? zoomLevel.id : tile.level.toString();
+        const urlParameters = {
+            transparent: this.transparent,
+            bgcolor: this.transparent ? undefined : this.bgcolor
+        };
+        const query = OgcOpenApiTilesModel.createURLParameters(urlParameters);
+        const targetUrl = baseURL.replace("{tileMatrix}", level).replace("{tileRow}", tileCorrected.y.toString()).replace("{tileCol}", tileCorrected.x.toString());
+        return targetUrl + (query && query !== "") ? targetUrl + "?" + query : targetUrl;
+    }
+    debugAsImage(tileCorrected) {
+        const canvas = document.createElement('canvas');
+        if (canvas) {
+            canvas.width = this.getTileWidth(tileCorrected.level);
+            canvas.height = this.getTileHeight(tileCorrected.level);
+            const ctx = canvas.getContext("2d");
+            if (ctx) {
+                ctx.font = "30px Arial";
+                ctx.fillText(`x:${tileCorrected.x}, y:${tileCorrected.y}, z:${tileCorrected.level}`, 10, canvas.height / 2);
+            }
+            const dataURL = canvas.toDataURL();
+            return dataURL;
+        }
+        return null;
+    }
+    static createURLParameters(obj) {
+        let str = Object.keys(obj).filter(k => obj[k] !== undefined).map(function (key) {
+            if (Array.isArray(obj[key])) {
+                return key + '=' + obj[key].join(",");
+            }
+            if (typeof obj[key] == "boolean") {
+                return key + '=' + (obj[key] ? "true" : "false");
+            }
+            return key + '=' + obj[key];
+        }).join('&');
+        return str;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ogcopenapis",
-  "version": "0.0.1",
-  "description": "",
+  "version": "0.0.3",
+  "description": "Implements OGC OPEN API Features/Maps/Tiles capabilities and models for LuciadRIA",
   "files": [
     "lib/"
   ],
@@ -23,7 +23,10 @@
     "@babel/preset-typescript": "^7.18.6",
     "@jest/globals": "^29.3.1",
     "copyfiles": "^2.3.0",
+    "isomorphic-fetch": "^3.0.0",
     "jest": "^29.3.1",
+    "jest-canvas-mock": "^2.4.0",
+    "jest-environment-jsdom": "^29.3.1",
     "typescript": "^4.6.3"
   },
   "dependencies": {