@itwin/map-layers-formats 4.1.0-dev.8 → 4.1.0-dev.80

package/src/ArcGisFeature/ArcGisFeatureQuery.ts

@@ -1,226 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-/** @internal */
-export type ArcGisFeatureResultType = "none" | "standard" | "tile";
-
-/** @internal */
-export type ArcGisFeatureGeometryType =
- "esriGeometryNull"
- | "esriGeometryPoint"
- | "esriGeometryMultipoint"
- | "esriGeometryLine"
- | "esriGeometryCircularArc"
- | "esriGeometryEllipticArc"
- | "esriGeometryBezier3Curve"
- | "esriGeometryPath"
- | "esriGeometryPolyline"
- | "esriGeometryRing"
- | "esriGeometryPolygon"
- | "esriGeometryEnvelope"
- | "esriGeometryAny"
- | "esriGeometryBag"
- | "esriGeometryMultiPatch"
- | "esriGeometryTriangleStrip"
- | "esriGeometryTriangeFan"
- | "esriGeometryRay"
- | "esriGeometrySphere"
- | "esriGeometryTriangles";
-
-/** @internal */
-export type ArcGisFeatureSpatialRel =  "esriSpatialRelIntersects" | "esriSpatialRelContains" | "esriSpatialRelCrosses" | "esriSpatialRelEnvelopeIntersects" | "esriSpatialRelIndexIntersects" | "esriSpatialRelOverlaps" | "esriSpatialRelTouches" | "esriSpatialRelWithin";
-
-/** @internal */
-export interface ArcGisGeometry {
-  type: ArcGisFeatureGeometryType;
-  geom: ArcGisExtent | ArcGisPointGeometry;
-}
-
-/** @internal */
-export interface ArcGisSpatialReference {
-  wkid: number;
-  latestWkid: number;
-}
-
-/** @internal */
-export interface ArcGisExtent {
-  xmin: number;
-  xmax: number;
-  ymin: number;
-  ymax: number;
-  spatialReference: ArcGisSpatialReference;
-}
-
-/** @internal */
-export interface ArcGisPointGeometry {
-  x: number;
-  y: number;
-  spatialReference: ArcGisSpatialReference;
-}
-
-/** @internal */
-export interface FeatureQueryQuantizationParams {
-  extent: ArcGisExtent;
-  mode: "view" | "edit";
-  originPosition: "upperLeft" | "lowerLeft";
-  tolerance: number;
-}
-
-/** @internal */
-export type ArcGisFeatureFormat = "JSON" | "PBF";
-
-// Based on official documentation:
-// https://developers.arcgis.com/rest/services-reference/query-feature-service-layer-.htm
-/** @internal */
-export interface ArcGisFeatureQueryParams {
-
-  /** This option can be used for fetching query results up to the resultRecordCount specified.
-   * When resultOffset is specified but this parameter is not, the map service defaults it to maxRecordCount.
-   * The maximum value for this parameter is the value of the layer's maxRecordCount property.
-   * The minimum value entered for this parameter cannot be below 1.
-   * This parameter only applies if supportsPagination is true.
-   * */
-  resultRecordCount?: number;
-
-  /** This option can be used for fetching query results up to the resultRecordCount specified.
-   * When resultOffset is specified but this parameter is not, the map service defaults it to maxRecordCount.
-   * The maximum value for this parameter is the value of the layer's maxRecordCount property.
-   * The minimum value entered for this parameter cannot be below 1.
-   * This parameter only applies if supportsPagination is true.
-   * */
-  resultOffset?: number;
-
-  /** If true, the result includes the geometry associated with each feature returned. */
-  returnGeometry?: boolean;
-  geometry?: ArcGisGeometry;
-  geometryType?: ArcGisFeatureGeometryType;
-  spatialRel?: ArcGisFeatureSpatialRel;
-  resultType?: ArcGisFeatureResultType;
-  maxRecordCountFactor?: number;
-  returnExceededLimitFeatures?: boolean;
-  quantizationParameters?: FeatureQueryQuantizationParams;
-
-  /** The list of fields to be included in the returned result set. This list is a comma-delimited list of field names.
-   * You can also specify the wildcard "*" as the value of this parameter.
-   *  */
-  outFields?: string;
-
-  /** The buffer distance for the input geometries.
-   *  */
-  distance?: number;
-}
-
-/** @internal */
-export class ArcGisFeatureQuery {
-  public baseUrl: string;
-  public layerIdx: number;
-  public format: ArcGisFeatureFormat;
-  public resultRecordCount?: number;
-  public resultOffset?: number;
-  public returnGeometry?: boolean;
-  public geometry?: ArcGisGeometry;
-  public spatialRel?: ArcGisFeatureSpatialRel;
-  public resultType?: ArcGisFeatureResultType;
-  public maxRecordCountFactor?: number;
-  public returnExceededLimitFeatures?: boolean;
-  public outSR: number;
-  public outFields?: string;
-  public distance?: number;
-
-  // public envelopeFilter?: CartographicRange;
-  public quantizationParams?: FeatureQueryQuantizationParams;
-
-  // base url is expected ito be in the format of:
-  // https://<hostname>/arcgis/rest/services/<ServiceName>/FeatureServer
-  public constructor(baseUrl: string, layerIdx: number, format: ArcGisFeatureFormat, outSR: number, params?: ArcGisFeatureQueryParams) {
-    this.baseUrl = baseUrl;
-    this.layerIdx = layerIdx;
-    this.format = format;
-    this.outSR = outSR;
-
-    if (params !== undefined) {
-      this.resultRecordCount = params.resultRecordCount;
-      this.resultOffset = params.resultOffset;
-      this.returnGeometry = params.returnGeometry;
-      this.geometry = params.geometry;
-      this.spatialRel = params.spatialRel;
-      this.resultType = params.resultType;
-      this.maxRecordCountFactor = params.maxRecordCountFactor;
-      this.returnExceededLimitFeatures = params.returnExceededLimitFeatures;
-      this.quantizationParams = params.quantizationParameters;
-      this.outFields = params.outFields;
-      this.distance = params.distance;
-    }
-
-  }
-
-  public toString() {
-    const url = new URL(`${this.baseUrl}/${this.layerIdx}/query`);
-
-    url.searchParams.append("f", this.format);
-
-    if ( this.resultRecordCount !== undefined) {
-      url.searchParams.append("resultRecordCount", `${this.resultRecordCount}`);
-    }
-
-    if ( this.resultOffset !== undefined) {
-      url.searchParams.append( "resultOffset", `${this.resultOffset}`);
-    }
-
-    if ( this.returnGeometry !== undefined) {
-      url.searchParams.append("returnGeometry", this.returnGeometry?"true":"false");
-    }
-
-    if ( this.resultType !== undefined) {
-      url.searchParams.append("resultType", this.resultType);
-    }
-
-    if ( this.maxRecordCountFactor !== undefined) {
-      url.searchParams.append( "maxRecordCountFactor", `${this.maxRecordCountFactor}`);
-    }
-
-    if ( this.returnExceededLimitFeatures !== undefined) {
-      url.searchParams.append( "returnExceededLimitFeatures", this.returnExceededLimitFeatures?"true":"false");
-    }
-
-    url.searchParams.append( "outSR", `${this.outSR}`);
-
-    if (this.geometry || this.spatialRel) {
-
-      if (this.spatialRel) {
-        url.searchParams.append( "spatialRel", this.spatialRel);
-      }
-
-      if (this.geometry) {
-        url.searchParams.append( "geometryType", this.geometry.type);
-
-        const geomStr = JSON.stringify(this.geometry.geom);
-        url.searchParams.append( "geometry", geomStr);
-        url.searchParams.append( "units", "esriSRUnit_Meter");    // required on older server for get feature info
-
-        url.searchParams.append( "inSR", `${this.geometry.geom.spatialReference.wkid}`);
-      }
-    } else {
-      // No custom params, fetch all geometries
-      url.searchParams.append("where", "1=1");
-    }
-
-    if (this.quantizationParams) {
-      const quantizationParamsStr = JSON.stringify(this.quantizationParams);
-      url.searchParams.append("quantizationParameters", quantizationParamsStr);
-    }
-
-    if (this.outFields) {
-      url.searchParams.append( "outFields", this.outFields);
-    }
-
-    if (this.distance) {
-      url.searchParams.append("distance", `${this.distance}`);
-    }
-
-    return url.toString();
-  }
-
-}

package/src/ArcGisFeature/ArcGisFeatureReader.ts

@@ -1,46 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { Primitives, StandardTypeNames } from "@itwin/appui-abstract";
-import { ImageMapLayerSettings } from "@itwin/core-common";
-import { MapLayerFeatureInfo } from "@itwin/core-frontend";
-import { ArcGisFeatureRenderer } from "./ArcGisFeatureRenderer";
-import { ArcGisResponseData } from "./ArcGisFeatureResponse";
-
-/** @internal */
-export abstract class ArcGisFeatureReader  {
-  // Optionally you can set the floating precision
-  public floatPrecision: number|undefined;
-
-  // Force display value of date to ISO 8601 format.
-  // Turning this ON, will disable display value in end-user's locale
-  public forceDateDisplayValueToIso = false;
-
-  protected _settings: ImageMapLayerSettings;
-  protected _layerMetadata: any;
-
-  public constructor(settings: ImageMapLayerSettings, layerMetadata: any) {
-    this._settings = settings;
-    this._layerMetadata = layerMetadata;
-  }
-
-  public abstract readAndRender(response: ArcGisResponseData, _renderer: ArcGisFeatureRenderer): void;
-
-  public abstract readFeatureInfo(response: ArcGisResponseData, featureInfos: MapLayerFeatureInfo[]): void;
-
-  protected  toFixedWithoutPadding = (value: number) => {
-    return (this.floatPrecision === undefined ? value : parseFloat(value.toFixed(this.floatPrecision)));
-  };
-
-  protected getDisplayValue = (typename: StandardTypeNames, value: Primitives.Value|undefined) => {
-    if (value === undefined) {
-      return  "";
-    } else if ( typename === StandardTypeNames.DateTime && this.forceDateDisplayValueToIso) {
-      return (value as Date).toISOString();
-    } else {
-      return `${value}`;
-    }
-  };
-}

package/src/ArcGisFeature/ArcGisFeatureRenderer.ts

@@ -1,171 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { Transform } from "@itwin/core-geometry";
-import { ArcGisSymbologyRenderer } from "./ArcGisSymbologyRenderer";
-
-/** @internal */
-export class ArcGisFeatureRenderer  {
-  private _symbol: ArcGisSymbologyRenderer;
-  private _transform: Transform|undefined;
-  private _context: CanvasRenderingContext2D;
-
-  constructor(context: CanvasRenderingContext2D, symbol: ArcGisSymbologyRenderer, world2PixelTransform?: Transform) {
-    this._symbol = symbol;
-    this._context = context;
-    this._transform = world2PixelTransform;
-  }
-
-  public get transform() {return this._transform;}
-
-  // Utility functions to make ease testing.
-  private closePath() {
-    this._context.closePath();
-  }
-
-  private lineTo(x: number, y: number) {
-    this._context.lineTo(x,y);
-  }
-
-  private moveTo(x: number, y: number) {
-    this._context.moveTo(x,y);
-  }
-
-  private fill() {
-    this._context.fill();
-  }
-
-  private stroke() {
-    this._context.stroke();
-  }
-
-  /**
-   * Render a path on the renderer's context.
-   * Note: Inputs are designed based on the PBF format, to avoid any data transformation.
-   * @param geometryLengths  Array be used to determine the start and end of each sub-path / rings. (i.e. [5,5] =  two rings of 5 vertices)
-   * @param geometryCoords Array that linearly encodes the vertices of each sub-path of a polyline / ring of a polygon
-   * @param fill Indicates if the path should be filled or not.
-   * @param stride Dimension of each vertices (i.e. 2 or 3.  3 could be X,Y,Z, X,YM) Currently 3rd dimension is ignored.
-  */
-  public renderPath(geometryLengths: number[], geometryCoords: number[], fill: boolean, stride: number, relativeCoords: boolean) {
-    if (stride < 2 || stride > 3) {
-      return;
-    }
-
-    // Keep track of our position in the in the 'coords' array:
-    // Every time we loop on the 'lengths' array, the position
-    // to start reading vertices in the 'coords' must be the sum of all previously read vertices.
-    let coordsOffset = 0;
-
-    // Begin the path here.
-    // Note: Even though path is closed inside the 'geometryLengths' loop,
-    //       it's import to begin the path only once.
-    this._context.beginPath();
-    for (const vertexCount of geometryLengths) {
-      let lastPtX = 0, lastPtY = 0;
-      for (let vertexIdx=0 ; vertexIdx <vertexCount; vertexIdx++) {
-        let pX = geometryCoords[coordsOffset+(vertexIdx*stride)];
-        let pY = geometryCoords[coordsOffset+(vertexIdx*stride)+1];
-        if (vertexIdx === 0) {
-          // first vertex is always "absolute" and must be drawn as 'moveTo' (i.e. not lineTo)
-          if (relativeCoords) {
-            lastPtX = pX;
-            lastPtY = pY;
-          }
-
-          if (this._transform) {
-            const transformedPoint = this._transform.multiplyPoint2d({x: pX, y:pY});
-            pX = transformedPoint.x;
-            pY = transformedPoint.y;
-          }
-
-          this.moveTo(pX, pY);
-        } else {
-
-          // Following vertices are relative to the previous one (sadly not really well documented by ESRI)
-          // typically this happens when 'coordinates quantization' is active (i.e. no client side transformation is needed)
-          if (relativeCoords) {
-            pX = lastPtX = lastPtX+pX;
-            pY = lastPtY = lastPtY+pY;
-          }
-
-          if (this._transform) {
-            const transformedPoint = this._transform.multiplyPoint2d({x: pX, y:pY});
-            pX = transformedPoint.x;
-            pY = transformedPoint.y;
-          }
-          this.lineTo(pX, pY);
-        }
-
-      }
-      coordsOffset+=stride*vertexCount;
-      if (fill) {
-        // ClosePath but do not 'fill' here, only at the very end (otherwise it will mess up holes)
-        this.closePath();
-      }
-    }
-
-    if (fill) {
-      this._symbol.applyFillStyle(this._context);
-      this.fill();
-    }
-
-    this._symbol.applyStrokeStyle(this._context);
-    this.stroke();  // draw line path or polygon outline
-  }
-
-  /**
-   * Render a point on the renderer's context.
-   * Note: Inputs are designed based on the PBF format, to avoid any data transformation.
-   * @param geometryLengths  Array be used to determine the start and end of each multi-point array, empty for single point.
-   * @param geometryCoords Array that linearly encodes vertices.
-   * @param stride Dimension of each vertices (i.e. 2 or 3.  3 could be X,Y,Z, X,YM) Currently 3rd dimension is ignored.
-  */
-  public renderPoint(geometryLengths: number[], geometryCoords: number[], stride: number, relativeCoords: boolean)  {
-
-    if (stride < 2 || stride > 3) {
-      return;
-    }
-    let coordsOffset = 0;
-    if (geometryLengths.length === 0) {
-      // Strangely, for points, 'lengths' array is empty, so we assume there is a single vertex in 'coords' array.
-      if (geometryCoords.length >= stride) {
-
-        if (this._transform) {
-          const transformedPoint = this._transform.multiplyPoint2d({x: geometryCoords[0], y:geometryCoords[1]});
-          this._symbol.drawPoint(this._context, transformedPoint.x, transformedPoint.y);
-        } else {
-          this._symbol.drawPoint(this._context, geometryCoords[0], geometryCoords[1]);
-        }
-      }
-    } else {
-      // MULTI-POINTS: Needs testing
-      // I assume 'lengths' array will get populated and 'coords' array will look similar to line/polygons.
-      for (const vertexCount of geometryLengths) {
-        let lastPtX = 0, lastPtY = 0;
-        for (let vertexIdx=0 ; vertexIdx <vertexCount; vertexIdx++) {
-          let pX = geometryCoords[coordsOffset+(vertexIdx*stride)];
-          let pY = geometryCoords[coordsOffset+(vertexIdx*stride)+1];
-
-          if (relativeCoords) {
-            pX = lastPtX = lastPtX+pX;
-            pY = lastPtY = lastPtY+pY;
-          }
-
-          if (this._transform) {
-            const transformedPoint = this._transform.multiplyPoint2d({x: pX, y:pY});
-            pX = transformedPoint.x;
-            pY = transformedPoint.y;
-          }
-
-          this._symbol.drawPoint(this._context, pX, pY);
-
-        }
-        coordsOffset+=stride*vertexCount;
-      }
-    }
-
-  }
-
-}

package/src/ArcGisFeature/ArcGisFeatureResponse.ts

@@ -1,72 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-
-import { ArcGisExtent, ArcGisFeatureFormat } from "./ArcGisFeatureQuery";
-import { esriPBuffer } from "./esriPBuffer.gen";
-
-/** @internal */
-export interface ArcGisResponseData {
-  data: any;
-  exceedTransferLimit: boolean;
-}
-
-/** @internal */
-export type ArcGisFieldType =
-  "esriFieldTypeInteger"
-  | "esriFieldTypeSmallInteger"
-  | "esriFieldTypeDouble"
-  | "esriFieldTypeSingle"
-  | "esriFieldTypeString"
-  | "esriFieldTypeDate"
-  | "esriFieldTypeGeometry"
-  | "esriFieldTypeOID"
-  | "esriFieldTypeBlob"
-  | "esriFieldTypeGlobalID"
-  | "esriFieldTypeRaster"
-  | "esriFieldTypeGUID"
-  | "esriFieldTypeXML";
-
-/** @internal */
-export class ArcGisFeatureResponse {
-  public readonly format: ArcGisFeatureFormat;
-  public readonly envelope: ArcGisExtent | undefined;
-
-  private _response: Promise<Response>;
-
-  constructor(format: ArcGisFeatureFormat,  response: Promise<Response>, envelope?: ArcGisExtent) {
-    this.format = format;
-    this._response = response;
-    this.envelope = envelope;
-  }
-
-  public async getResponseData(): Promise<ArcGisResponseData|undefined> {
-    let data: any|undefined;
-    try {
-      const tileResponse = await this._response;
-      if (tileResponse === undefined || tileResponse.status !== 200  )
-        return undefined;
-
-      if (this.format === "PBF") {
-        const byteArray: Uint8Array = new Uint8Array(await tileResponse.arrayBuffer());
-        if (!byteArray || (byteArray.length === 0))
-          return undefined;
-
-        data = esriPBuffer.FeatureCollectionPBuffer.deserialize(byteArray);
-        const collection = data as esriPBuffer.FeatureCollectionPBuffer;
-        return {data, exceedTransferLimit: collection?.queryResult?.featureResult?.exceededTransferLimit};
-
-      } else {
-        data = await tileResponse.json();
-        if (data === undefined || data == null)
-          return undefined;
-
-        return {data, exceedTransferLimit: data.exceededTransferLimit};
-      }
-
-    } catch(_e) {
-      return undefined;
-    }
-  }
-}