ogcopenapis 0.0.3 → 0.0.5

package/lib/OgcOpenApiCrsTools.d.ts

@@ -4,6 +4,6 @@ declare class OgcOpenApiCrsTools {
      * @param uriOrName
      * @private
      */
-    static getReferenceName(uriOrName: string): string;
+    static getReferenceName(uriOrNameI: string): string;
 }
 export { OgcOpenApiCrsTools };

package/lib/OgcOpenApiCrsTools.js

@@ -4,7 +4,10 @@ class OgcOpenApiCrsTools {
      * @param uriOrName
      * @private
      */
-    static getReferenceName(uriOrName) {
+    static getReferenceName(uriOrNameI) {
+        if (typeof uriOrNameI === "undefined")
+            return uriOrNameI;
+        const uriOrName = uriOrNameI.replace(/[<>]/g, '');
         if (!uriOrName.startsWith('http')) {
             return uriOrName;
         }

package/lib/OgcOpenApiFeatureStore.d.ts

@@ -5,12 +5,14 @@ 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 {
+import { ProxifyFunction } from "./OgcOpenApiGetCapabilities";
+export interface OgcOpenApiFeatureStoreConstructorOptions {
     dataUrl: string;
     featureUrl?: string;
     outputFormat: string;
-    useCrs84Bounds: boolean;
+    useCrs84Bounds?: boolean;
     codec: Codec;
+    credentials?: boolean;
     requestHeaders?: {
         [key: string]: string;
     };
@@ -21,8 +23,9 @@ interface OAPIFeatureStoreConstructorOptions {
         };
     };
     reference: CoordinateReference;
+    proxify?: ProxifyFunction;
 }
-interface OAPIFeatureStoreQueryOptions {
+export interface OgcOpenApiFeatureStoreQueryOptions {
     f?: string;
     limit?: number;
     offset?: number;
@@ -57,7 +60,7 @@ interface OAPIFeatureStoreQueryOptions {
     wkhrCode?: string;
     wkhrRemark?: string;
 }
-interface OgcOpenApiCodecDecodeOptions extends CodecDecodeOptions {
+interface OgcOpenApiFeaturesCodecDecodeOptions extends CodecDecodeOptions {
     contentCrs?: string;
     contentLength?: number;
 }
@@ -74,13 +77,16 @@ export declare class OgcOpenApiFeatureStore implements Store, Evented {
     private outputFormat;
     private useCrs84Bounds;
     private featureUrl;
-    constructor(options: OAPIFeatureStoreConstructorOptions);
+    private proxy;
+    private credentials;
+    private serverOptions;
+    constructor(options: OgcOpenApiFeatureStoreConstructorOptions);
     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;
+    query(receivedQuery?: OgcOpenApiFeatureStoreQueryOptions, options?: any): Cursor | Promise<Cursor>;
+    spatialQuery(bounds?: Bounds, receivedQuery?: OgcOpenApiFeatureStoreQueryOptions, options?: any): Promise<Cursor> | Cursor;
     private static getCRS84BoundingBox;
     private static cleanUrl;
     private static dataFormatInQuery;
 }
-export { OgcOpenApiCodecDecodeOptions };
+export { OgcOpenApiFeaturesCodecDecodeOptions };

package/lib/OgcOpenApiFeatureStore.js

@@ -2,6 +2,10 @@ 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";
+import { OgcOpenApiCrsTools } from "./OgcOpenApiCrsTools";
+import { GeoJsonCodec } from "@luciad/ria/model/codec/GeoJsonCodec";
+import { GMLCodec } from "@luciad/ria/model/codec/GMLCodec";
+import { OgcOpenApiFetchTools } from "./OgcOpenApiFetchTools";
 export class OgcOpenApiFeatureStore {
     constructor(options) {
         // console.log(options);
@@ -17,6 +21,9 @@ export class OgcOpenApiFeatureStore {
         this.eventedSupport = new EventedSupport();
         this.requestHeaders = options.requestHeaders ? options.requestHeaders : {};
         this.reference = options.reference;
+        this.proxy = options.proxify;
+        this.credentials = options.credentials;
+        this.serverOptions = OgcOpenApiFetchTools.createFetchOptions({ originalUrl: this.dataUrl, proxify: options.proxify });
         if (options.extent &&
             options.extent.spatial &&
             options.extent.spatial.bbox &&
@@ -60,14 +67,15 @@ export class OgcOpenApiFeatureStore {
                 request += "?" + queryString;
             }
             const headers = Object.assign(Object.assign({}, this.requestHeaders), { Accept: accept });
-            fetch(request, {
+            OgcOpenApiFetchTools.fetch(request, {
                 method: 'GET',
+                credentials: this.credentials ? "same-origin" : "omit",
                 headers,
-            }).then((response) => {
+            }, this.serverOptions).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 contentCrs = response.headers.get('content-crs') ? response.headers.get('content-crs') : this.customCrs;
                         const contentLengthStr = response.headers.get('Content-Length');
                         const contentLength = Number(contentLengthStr);
                         contentType = contentType ? contentType : 'text/plain';
@@ -120,14 +128,15 @@ export class OgcOpenApiFeatureStore {
             }
             const headers = Object.assign(Object.assign({}, this.requestHeaders), { Accept: accept });
             // const headers = { ...this.requestHeaders };
-            fetch(request, {
+            OgcOpenApiFetchTools.fetch(request, {
                 method: 'GET',
+                credentials: this.credentials ? "same-origin" : "omit",
                 headers,
-            }).then((response) => {
+            }, this.serverOptions).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 contentCrs = response.headers.get('content-crs') ? response.headers.get('content-crs') : this.customCrs;
                         const contentLengthStr = response.headers.get('Content-Length');
                         const contentLength = Number(contentLengthStr);
                         contentType = contentType ? contentType : 'text/plain';
@@ -137,8 +146,14 @@ export class OgcOpenApiFeatureStore {
                         const codecOptions = {
                             content, contentType, contentCrs, contentLength
                         };
-                        const cursor = this.codec.decode(codecOptions);
-                        resolve(cursor);
+                        if (this.codec instanceof GeoJsonCodec || this.codec instanceof GMLCodec) {
+                            const cursor = this.codec.decode(Object.assign(Object.assign({}, codecOptions), { reference: getReference(OgcOpenApiCrsTools.getReferenceName(contentCrs)) }));
+                            resolve(cursor);
+                        }
+                        else {
+                            const cursor = this.codec.decode(codecOptions);
+                            resolve(cursor);
+                        }
                     });
                 }
             });

package/lib/OgcOpenApiFetchTools.d.ts

@@ -1,10 +1,8 @@
+import { ProxifyFunction } from "./OgcOpenApiGetCapabilities";
 interface ExtFetchOptions {
     originalUrl: string;
     complete?: (url: string) => string;
-    proxify?: (url: string) => {
-        url: string;
-        fetchOptions: RequestInit;
-    };
+    proxify?: ProxifyFunction;
 }
 export interface FetchServerOptions {
     proxy: (url: string, fetchOptions: any) => {

package/lib/OgcOpenApiFetchTools.js

@@ -18,6 +18,8 @@ class OgcOpenApiFetchTools {
         return fetch(result.url, result.fetchOptions);
     }
     static addHostURL(url, HostUrl) {
+        if (typeof url === "undefined")
+            return url;
         const hostUrl = HostUrl ? HostUrl : "";
         if (url.startsWith("http://") || url.startsWith("https://")) {
             return url;

package/lib/OgcOpenApiGetCapabilities.d.ts

@@ -76,16 +76,17 @@ export declare enum CollectionLinkType {
     Map = "map",
     Tiles = "tiles"
 }
+export type ProxifyFunction = (url: string, fetchOptions: RequestInit) => {
+    url: string;
+    fetchOptions: RequestInit;
+};
 export interface OgcOpenApiGetCapabilitiesFromURL {
     filterCollectionsByLinkType?: CollectionLinkType;
     credentials?: boolean;
     requestHeaders?: {
         [headerName: string]: string;
     } | null;
-    proxify?: (url: string) => {
-        url: string;
-        fetchOptions: RequestInit;
-    };
+    proxify?: ProxifyFunction;
 }
 export declare class OgcOpenApiGetCapabilities {
     static fromURL(inputRequest: string, options?: OgcOpenApiGetCapabilitiesFromURL): Promise<OgcOpenApiCapabilitiesObject>;
@@ -98,10 +99,7 @@ export declare class OgcOpenApiGetCapabilities {
         requestHeaders?: RequestHeaders;
     }): Promise<TileSetData[]>;
     static getQuadTreeCompatibleLevelOffset(tileMatrixSet: TileSetData): number;
-    static fetchTileSets(capabilities: OgcOpenApiCapabilitiesObject | null, options?: {
-        credentials?: boolean;
-        requestHeaders?: RequestHeaders;
-    }): Promise<TileSetMeta[]>;
+    private static fetchTileSets;
     static getTilesLink(capabilities: OgcOpenApiCapabilitiesObject | null, currentCollection: OgcOpenApiCapabilitiesCollection, tileMatrixId: string, options?: {
         credentials?: boolean;
         requestHeaders?: RequestHeaders;

package/lib/OgcOpenApiGetCapabilities.js

@@ -64,12 +64,13 @@ export class OgcOpenApiGetCapabilities {
                                     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);
+                                            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 });
+                                const o = Object.assign(Object.assign({ name: '', collections: foundCollections.map(col => (Object.assign(Object.assign({}, col), { crs: col.crs ? col.crs : [], links: col.links.map(l => (Object.assign(Object.assign({}, l), { href: serverOptions.complete(l.href) }))) }))), version: responseOpenApi ? responseOpenApi.openapi : '', service: '', info: responseOpenApi ? responseOpenApi.info : {} }, crsArray), { serverOptions: serverOptions, baseUrl });
                                 resolve(o);
                             });
                         }
@@ -183,7 +184,7 @@ export class OgcOpenApiGetCapabilities {
                 if (result.status === 200) {
                     result.json().then((data) => {
                         if (data.tileMatrixSets) {
-                            resolve(data.tileMatrixSets);
+                            resolve(data.tileMatrixSets.map(tml => (Object.assign(Object.assign({}, tml), { href: capabilities.serverOptions.complete(tml.href) }))));
                         }
                         else {
                             reject({ error: true, message: "tileMatrixSets not defined" });

package/lib/OgcOpenApiMapsModel.d.ts

@@ -2,12 +2,14 @@ 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";
+import { ProxifyFunction } from "./OgcOpenApiGetCapabilities";
 interface OgcOpenApiMapsModelConstructorOptions {
     crs: string;
     baseURL: string;
     collection: string;
     dataType?: RasterDataType;
     samplingMode?: RasterSamplingMode;
+    credentials?: boolean;
     requestHeaders?: {
         [p: string]: string;
     };
@@ -17,6 +19,7 @@ interface OgcOpenApiMapsModelConstructorOptions {
     subset?: string[];
     transparent?: boolean;
     bgcolor?: string;
+    proxify?: ProxifyFunction;
 }
 declare class OgcOpenApiMapsModel extends WMSTileSetModel {
     private format;
@@ -25,6 +28,7 @@ declare class OgcOpenApiMapsModel extends WMSTileSetModel {
     private datetime;
     private subset;
     private bgcolor;
+    private proxy;
     constructor(o: OgcOpenApiMapsModelConstructorOptions);
     getTileURL(baseURL: string, tile: TileCoordinate): string | null;
     private static createURLParameters;

package/lib/OgcOpenApiMapsModel.js

@@ -11,6 +11,7 @@ class OgcOpenApiMapsModel extends WMSTileSetModel {
             layers: [o.collection],
             dataType: o.dataType,
             samplingMode: o.samplingMode,
+            credentials: o.credentials,
             requestHeaders: o.requestHeaders
         });
         this.crs = o.crs;
@@ -20,6 +21,7 @@ class OgcOpenApiMapsModel extends WMSTileSetModel {
         this.subset = o.subset;
         this.transparent = typeof o.transparent !== "undefined" ? o.transparent : true;
         this.bgcolor = o.bgcolor;
+        this.proxy = o.proxify;
         this.modelDescriptor = {
             source: o.baseURL,
             name: o.collection,
@@ -46,7 +48,11 @@ class OgcOpenApiMapsModel extends WMSTileSetModel {
                 bgcolor: this.transparent ? undefined : this.bgcolor
             };
             const query = OgcOpenApiMapsModel.createURLParameters(urlParameters);
-            const transformedUrl = url + "?" + query;
+            let transformedUrl = url + "?" + query;
+            if (typeof this.proxy === "function") {
+                const proxyfied = this.proxy(transformedUrl, {});
+                transformedUrl = proxyfied.url;
+            }
             return transformedUrl;
         }
         else {

package/lib/OgcOpenApiTilesModel.d.ts

@@ -2,18 +2,20 @@ 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";
+import { ProxifyFunction, TileSetData } from "./OgcOpenApiGetCapabilities";
 export interface OgcOpenApiTilesModelOptions {
     tileMatrix: TileSetData;
     baseURL: string;
     collection: string;
     dataType?: RasterDataType;
     samplingMode?: RasterSamplingMode;
+    credentials?: boolean;
     requestHeaders?: {
         [p: string]: string;
     };
     transparent?: boolean;
     bgcolor?: string;
+    proxify?: ProxifyFunction;
 }
 export declare class OgcOpenApiTilesModel extends UrlTileSetModel {
     private tileMatrix;
@@ -21,6 +23,7 @@ export declare class OgcOpenApiTilesModel extends UrlTileSetModel {
     private plevel0Rows;
     private transparent;
     private bgcolor;
+    private proxy;
     constructor(options: OgcOpenApiTilesModelOptions);
     getTileURL(baseURL: string, tile: TileCoordinate): string | null;
     debugAsImage(tileCorrected: TileCoordinate): string;

package/lib/OgcOpenApiTilesModel.js

@@ -61,6 +61,7 @@ export class OgcOpenApiTilesModel extends UrlTileSetModel {
             level0Rows,
             dataType: options.dataType,
             samplingMode: options.samplingMode,
+            credentials: options.credentials,
             requestHeaders: options.requestHeaders ? options.requestHeaders : {},
         };
         super(o);
@@ -69,6 +70,7 @@ export class OgcOpenApiTilesModel extends UrlTileSetModel {
         this.bgcolor = options.bgcolor;
         this.invertY = invertY;
         this.tileMatrix = options.tileMatrix;
+        this.proxy = options.proxify;
         this.modelDescriptor = {
             source: options.baseURL,
             name: options.collection,
@@ -89,7 +91,12 @@ export class OgcOpenApiTilesModel extends UrlTileSetModel {
         };
         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;
+        let tileUrl = targetUrl + (query && query !== "") ? targetUrl + "?" + query : targetUrl;
+        if (typeof this.proxy === "function") {
+            const proxyfied = this.proxy(tileUrl, {});
+            tileUrl = proxyfied.url;
+        }
+        return tileUrl;
     }
     debugAsImage(tileCorrected) {
         const canvas = document.createElement('canvas');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ogcopenapis",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Implements OGC OPEN API Features/Maps/Tiles capabilities and models for LuciadRIA",
   "files": [
     "lib/"