ogcopenapis 0.0.4 → 0.0.6

package/lib/OgcOpenApiCrsTools.d.ts

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

package/lib/OgcOpenApiCrsTools.js

@@ -4,7 +4,14 @@ class OgcOpenApiCrsTools {
      * @param uriOrName
      * @private
      */
-    static getReferenceName(uriOrName) {
+    static getReferenceName(uriOrNameI) {
+        let uriOrName;
+        if (typeof uriOrNameI === "undefined") {
+            uriOrName = "http://www.opengis.net/def/crs/OGC/1.3/CRS84";
+        }
+        else {
+            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';
+import { ProxifyFunction } from "./OgcOpenApiGetCapabilities";
 export interface OgcOpenApiFeatureStoreConstructorOptions {
     dataUrl: string;
     featureUrl?: string;
     outputFormat: string;
     useCrs84Bounds?: boolean;
     codec: Codec;
+    credentials?: boolean;
     requestHeaders?: {
         [key: string]: string;
     };
@@ -21,6 +23,7 @@ export interface OgcOpenApiFeatureStoreConstructorOptions {
         };
     };
     reference: CoordinateReference;
+    proxify?: ProxifyFunction;
 }
 export interface OgcOpenApiFeatureStoreQueryOptions {
     f?: string;
@@ -74,6 +77,9 @@ export declare class OgcOpenApiFeatureStore implements Store, Evented {
     private outputFormat;
     private useCrs84Bounds;
     private featureUrl;
+    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>;

package/lib/OgcOpenApiFeatureStore.js

@@ -5,6 +5,7 @@ import { createTransformation } from "@luciad/ria/transformation/TransformationF
 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);
@@ -20,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 &&
@@ -63,10 +67,11 @@ 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');
@@ -123,10 +128,11 @@ 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');

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/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>;

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.4",
+  "version": "0.0.6",
   "description": "Implements OGC OPEN API Features/Maps/Tiles capabilities and models for LuciadRIA",
   "files": [
     "lib/"