esri-gl 0.9.0-alpha.10

package/dist/types/Services/Service.d.ts

@@ -0,0 +1,118 @@
+import type { Map, ServiceMetadata } from '@/types';
+export interface ServiceOptions {
+    url: string;
+    proxy?: boolean;
+    useCors?: boolean;
+    timeout?: number;
+    token?: string;
+    requestParams?: Record<string, unknown>;
+    getAttributionFromService?: boolean;
+}
+export type ServiceCallback<T = unknown> = (error?: Error, response?: T) => void;
+export interface ServiceEvents {
+    requeststart: {
+        url: string;
+        params: Record<string, unknown>;
+        method: string;
+    };
+    requestsuccess: {
+        url: string;
+        params: Record<string, unknown>;
+        response: unknown;
+        method: string;
+    };
+    requesterror: {
+        url: string;
+        params: Record<string, unknown>;
+        message: string;
+        code?: number;
+        method: string;
+    };
+    requestend: {
+        url: string;
+        params: Record<string, unknown>;
+        method: string;
+    };
+    authenticationrequired: {
+        authenticate: (token: string) => void;
+    };
+}
+/**
+ * Base Service class for ArcGIS REST API services
+ * Similar to Esri Leaflet's Service class
+ */
+export declare class Service {
+    protected options: ServiceOptions & {
+        proxy: boolean;
+        useCors: boolean;
+        timeout: number;
+        getAttributionFromService: boolean;
+    };
+    protected _requestQueue: Array<[
+        string,
+        string,
+        Record<string, unknown>,
+        (error?: Error, response?: unknown) => void,
+        unknown
+    ]>;
+    protected _authenticating: boolean;
+    protected _serviceMetadata: ServiceMetadata | null;
+    protected _map?: Map;
+    private _eventListeners;
+    constructor(options: ServiceOptions);
+    /**
+     * Make a GET request
+     */
+    get(path: string, params?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Make a POST request
+     */
+    post(path: string, params?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Make a generic request
+     */
+    request(path: string, params?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Make a request with callback support (public for Tasks)
+     */
+    requestWithCallback<T = unknown>(method: string, path: string, params: Record<string, unknown>, callback?: ServiceCallback<T>): Promise<T> | void;
+    /**
+     * Get service metadata
+     */
+    metadata(): Promise<ServiceMetadata>;
+    /**
+     * Set authentication token
+     */
+    authenticate(token: string): Service;
+    /**
+     * Get request timeout
+     */
+    getTimeout(): number;
+    /**
+     * Set request timeout
+     */
+    setTimeout(timeout: number): Service;
+    /**
+     * Set attribution from service metadata
+     */
+    setAttributionFromService(): Promise<void>;
+    /**
+     * Add event listener
+     */
+    on<K extends keyof ServiceEvents>(event: K, callback: (event: ServiceEvents[K]) => void): Service;
+    /**
+     * Remove event listener
+     */
+    off<K extends keyof ServiceEvents>(event: K, callback: (event: ServiceEvents[K]) => void): Service;
+    /**
+     * Fire an event
+     */
+    fire<K extends keyof ServiceEvents>(event: K, data: ServiceEvents[K]): Service;
+    private _requestWithCallback;
+    private _request;
+    private _makeRequest;
+    private _createServiceCallback;
+    private _runQueue;
+}
+export declare function service(options: ServiceOptions): Service;
+export default service;

package/dist/types/Services/SimpleMapService.d.ts

@@ -0,0 +1,30 @@
+import { Service, ServiceOptions } from './Service';
+import { IdentifyFeatures } from '../Tasks/IdentifyFeatures';
+import { Query } from '../Tasks/Query';
+import { Find } from '../Tasks/Find';
+export interface MapServiceOptions extends ServiceOptions {
+}
+/**
+ * MapService - ArcGIS Server Map Service
+ * Exactly matches Esri Leaflet's MapService pattern
+ */
+export declare class MapService extends Service {
+    constructor(options: MapServiceOptions);
+    /**
+     * Return an IdentifyFeatures task instance
+     */
+    identify(): IdentifyFeatures;
+    /**
+     * Return a Query task instance
+     */
+    query(): Query;
+    /**
+     * Return a Find task instance
+     */
+    find(): Find;
+    export(params: Record<string, unknown>): Promise<{
+        href?: string;
+    }>;
+}
+export declare function mapService(options: MapServiceOptions): MapService;
+export default mapService;

package/dist/types/Services/TiledMapService.d.ts

@@ -0,0 +1,28 @@
+import type { Map, EsriServiceOptions, RasterSourceOptions, ServiceMetadata } from '@/types';
+interface TiledMapServiceOptions extends EsriServiceOptions {
+    fetchOptions?: RequestInit;
+}
+interface RasterSource {
+    type: 'raster';
+    tiles: string[];
+    tileSize?: number;
+    attribution?: string;
+    bounds?: number[];
+    minzoom?: number;
+    maxzoom?: number;
+}
+export declare class TiledMapService {
+    private _sourceId;
+    private _map;
+    private _serviceMetadata;
+    rasterSrcOptions?: RasterSourceOptions;
+    esriServiceOptions: TiledMapServiceOptions;
+    constructor(sourceId: string, map: Map, esriServiceOptions: TiledMapServiceOptions, rasterSrcOptions?: RasterSourceOptions);
+    get _source(): RasterSource;
+    private _createSource;
+    setAttributionFromService(): Promise<void>;
+    getMetadata(): Promise<ServiceMetadata>;
+    update(): void;
+    remove(): void;
+}
+export {};

package/dist/types/Services/VectorBasemapStyle.d.ts

@@ -0,0 +1,9 @@
+export declare class VectorBasemapStyle {
+    styleName: string;
+    private _apikey;
+    constructor(styleName?: string, apikey?: string);
+    get styleUrl(): string;
+    setStyle(styleName: string): void;
+    update(): void;
+    remove(): void;
+}

package/dist/types/Services/VectorTileService.d.ts

@@ -0,0 +1,41 @@
+import type { Map, VectorTileServiceOptions, VectorSourceOptions, ServiceMetadata } from '@/types';
+interface VectorTileServiceExtendedOptions extends VectorTileServiceOptions {
+    useDefaultStyle?: boolean;
+    fetchOptions?: RequestInit;
+}
+interface StyleLayoutPaint {
+    [key: string]: unknown;
+}
+interface StyleData {
+    type: string;
+    source?: string;
+    'source-layer': string;
+    layout?: StyleLayoutPaint;
+    paint?: StyleLayoutPaint;
+}
+export declare class VectorTileService {
+    private _sourceId;
+    private _map;
+    private _defaultEsriOptions;
+    private _serviceMetadata;
+    private _defaultStyleData;
+    vectorSrcOptions?: VectorSourceOptions;
+    esriServiceOptions: VectorTileServiceExtendedOptions;
+    constructor(sourceId: string, map: Map, esriServiceOptions: VectorTileServiceExtendedOptions, vectorSrcOptions?: VectorSourceOptions);
+    get options(): Required<VectorTileServiceExtendedOptions>;
+    get _tileUrl(): string;
+    get _source(): VectorSourceOptions & {
+        type: 'vector';
+        tiles: string[];
+    };
+    private _createSource;
+    private _mapToLocalSource;
+    get defaultStyle(): StyleData;
+    get _styleUrl(): string;
+    getStyle(): Promise<StyleData>;
+    private _retrieveStyle;
+    getMetadata(): Promise<ServiceMetadata>;
+    update(): void;
+    remove(): void;
+}
+export {};

package/dist/types/Tasks/Find.d.ts

@@ -0,0 +1,85 @@
+import { Task } from './Task';
+import { Service } from '@/Services/Service';
+export interface FindOptions {
+    url: string;
+    token?: string;
+    searchText?: string;
+    contains?: boolean;
+    searchFields?: string | string[];
+    sr?: string | number;
+    layers?: number | number[] | string;
+    returnGeometry?: boolean;
+    maxAllowableOffset?: number;
+    geometryPrecision?: number;
+    dynamicLayers?: unknown[];
+    returnZ?: boolean;
+    returnM?: boolean;
+    gdbVersion?: string;
+    layerDefs?: string;
+}
+/**
+ * Find task for searching text in ArcGIS Map Services
+ * Based on Esri Leaflet's Find functionality
+ */
+export declare class Find extends Task {
+    protected setters: {
+        contains: string;
+        text: string;
+        fields: string;
+        spatialReference: string;
+        sr: string;
+        layers: string;
+        returnGeometry: string;
+        maxAllowableOffset: string;
+        precision: string;
+        dynamicLayers: string;
+        returnZ: string;
+        returnM: string;
+        gdbVersion: string;
+        token: string;
+    };
+    protected path: string;
+    protected params: Record<string, unknown>;
+    constructor(options: string | FindOptions | Service);
+    /**
+     * Set the text to search for
+     */
+    text(searchText: string): Find;
+    /**
+     * Set the fields to search in
+     */
+    fields(fields: string | string[]): Find;
+    /**
+     * Set whether the search should contain the text (partial match) or exact match
+     */
+    contains(contains: boolean): Find;
+    /**
+     * Set which layers to search in
+     */
+    layers(layers: number | number[] | string): Find;
+    /**
+     * Set layer definitions for filtering specific layers
+     */
+    layerDefs(layerId: number | string, whereClause: string): Find;
+    /**
+     * Simplify geometries based on map resolution
+     */
+    simplify(map: {
+        getBounds(): {
+            getWest(): number;
+            getEast(): number;
+        };
+        getSize(): {
+            x: number;
+            y: number;
+        };
+    }, factor: number): Find;
+    /**
+     * Execute the find operation
+     */
+    run(): Promise<GeoJSON.FeatureCollection<GeoJSON.Geometry | null>>;
+    private _convertToGeoJSON;
+    private _convertEsriGeometry;
+}
+export declare function find(options: string | FindOptions): Find;
+export default find;

package/dist/types/Tasks/IdentifyFeatures.d.ts

@@ -0,0 +1,91 @@
+import { Task } from '@/Tasks/Task';
+import { Service } from '@/Services/Service';
+import type { Map } from '@/types';
+export interface IdentifyFeaturesOptions {
+    url: string;
+    layers?: number[] | number | string;
+    layerDefs?: Record<string, string>;
+    tolerance?: number;
+    returnGeometry?: boolean;
+    maxAllowableOffset?: number;
+    geometryPrecision?: number;
+    dynamicLayers?: unknown[];
+    mapExtent?: [number, number, number, number];
+    imageDisplay?: [number, number, number];
+    sr?: string | number;
+    layerTimeOptions?: Record<string, unknown>;
+    time?: number[] | Date[];
+    fetchOptions?: RequestInit;
+}
+export interface IdentifyResult {
+    layerId: number;
+    layerName: string;
+    value: string;
+    displayFieldName: string;
+    attributes: Record<string, unknown>;
+    geometry?: unknown;
+    geometryType?: string;
+}
+export interface IdentifyResponse {
+    results: IdentifyResult[];
+}
+export interface GeometryInput {
+    x: number;
+    y: number;
+    spatialReference?: {
+        wkid: number;
+        latestWkid?: number;
+    };
+}
+/**
+ * IdentifyFeatures task for performing identify operations against ArcGIS Map Services
+ * Similar to Esri Leaflet's identifyFeatures functionality
+ */
+export declare class IdentifyFeatures extends Task {
+    protected setters: {
+        layers: string;
+        precision: string;
+        tolerance: string;
+        returnGeometry: string;
+    };
+    protected path: string;
+    protected params: Record<string, unknown>;
+    constructor(options: string | IdentifyFeaturesOptions | Service);
+    /**
+     * Perform identify operation at a point location
+     */
+    at(point: {
+        lng: number;
+        lat: number;
+    } | [number, number]): IdentifyFeatures;
+    layers(value: number[] | number | string): IdentifyFeatures;
+    tolerance(value: number): IdentifyFeatures;
+    returnGeometry(value: boolean): IdentifyFeatures;
+    precision(value: number): IdentifyFeatures;
+    /**
+     * Set the map extent and image display for the identify operation
+     */
+    on(map: Map): IdentifyFeatures;
+    /**
+     * Set layer definitions for filtering specific layers
+     */
+    layerDef(layerId: number | string, whereClause: string): IdentifyFeatures;
+    /**
+     * Simplify geometries based on map resolution
+     */
+    simplify(map: {
+        getBounds(): {
+            getWest(): number;
+            getEast(): number;
+        };
+        getSize(): {
+            x: number;
+            y: number;
+        };
+    }, factor: number): IdentifyFeatures;
+    /**
+     * Execute the identify operation
+     */
+    run(): Promise<GeoJSON.FeatureCollection>;
+    private _convertToGeoJSON;
+}

package/dist/types/Tasks/IdentifyImage.d.ts

@@ -0,0 +1,107 @@
+import { Task } from '@/Tasks/Task';
+export interface IdentifyImageOptions {
+    url: string;
+    token?: string;
+    geometry?: unknown;
+    geometryType?: string;
+    sr?: string | number;
+    mosaic?: boolean;
+    renderingRules?: unknown[];
+    pixelSize?: [number, number];
+    returnGeometry?: boolean;
+    returnCatalogItems?: boolean;
+    f?: string;
+}
+export interface PixelValue {
+    attributes: Record<string, unknown>;
+    geometry?: unknown;
+}
+export interface IdentifyImageResult {
+    objectId?: number;
+    name?: string;
+    value?: string;
+    location?: {
+        x: number;
+        y: number;
+        spatialReference?: {
+            wkid: number;
+            latestWkid?: number;
+        };
+    };
+    attributes?: Record<string, unknown>;
+    catalogItems?: unknown[];
+    catalogItemVisibilities?: number[];
+}
+/**
+ * IdentifyImage task for identifying pixel values in ArcGIS Image Services
+ * Based on Esri Leaflet's IdentifyImage functionality
+ */
+export declare class IdentifyImage extends Task {
+    protected setters: {
+        returnCatalogItems: string;
+        returnGeometry: string;
+        pixelSize: string;
+        token: string;
+    };
+    protected path: string;
+    protected params: Record<string, unknown>;
+    constructor(options: string | IdentifyImageOptions);
+    /**
+     * Identify pixel values at a specific point
+     */
+    at(point: {
+        lng: number;
+        lat: number;
+    } | [number, number]): IdentifyImage;
+    /**
+     * Set custom geometry for identification
+     */
+    geometry(geometry: unknown, geometryType?: string): IdentifyImage;
+    /**
+     * Set pixel size for the identify operation
+     */
+    pixelSize(size: [number, number] | {
+        x: number;
+        y: number;
+    }): IdentifyImage;
+    /**
+     * Set whether to return geometry with results
+     */
+    returnGeometry(returnGeom: boolean): IdentifyImage;
+    /**
+     * Set whether to return catalog items
+     */
+    returnCatalogItems(returnItems: boolean): IdentifyImage;
+    /**
+     * Set mosaic rule for the identify operation
+     */
+    mosaicRule(rule: unknown): IdentifyImage;
+    /**
+     * Set rendering rules for the identify operation
+     */
+    renderingRule(rule: unknown): IdentifyImage;
+    /**
+     * Execute the identify operation
+     */
+    run(): Promise<{
+        results: IdentifyImageResult[];
+        location?: {
+            x: number;
+            y: number;
+            spatialReference?: {
+                wkid: number;
+                latestWkid?: number;
+            };
+        };
+    }>;
+    /**
+     * Execute and return pixel values as a simple array
+     */
+    getPixelValues(): Promise<Array<string | number | null>>;
+    /**
+     * Execute and return detailed pixel information
+     */
+    getPixelData(): Promise<IdentifyImageResult[]>;
+}
+export declare function identifyImage(options: string | IdentifyImageOptions): IdentifyImage;
+export default identifyImage;

package/dist/types/Tasks/Query.d.ts

@@ -0,0 +1,180 @@
+import { Task } from './Task';
+import { Service } from '@/Services/Service';
+export interface QueryOptions {
+    url: string;
+    token?: string;
+    where?: string;
+    outFields?: string | string[];
+    returnGeometry?: boolean;
+    spatialRel?: string;
+    geometry?: unknown;
+    geometryType?: string;
+    inSR?: string | number;
+    outSR?: string | number;
+    returnDistinctValues?: boolean;
+    returnIdsOnly?: boolean;
+    returnCountOnly?: boolean;
+    returnExtentOnly?: boolean;
+    orderByFields?: string;
+    groupByFieldsForStatistics?: string;
+    outStatistics?: unknown[];
+    resultOffset?: number;
+    resultRecordCount?: number;
+    maxAllowableOffset?: number;
+    geometryPrecision?: number;
+    time?: number[];
+    gdbVersion?: string;
+    historicMoment?: number;
+    returnTrueCurves?: boolean;
+    returnZ?: boolean;
+    returnM?: boolean;
+    f?: string;
+}
+export interface QueryGeometry {
+    x?: number;
+    y?: number;
+    xmin?: number;
+    ymin?: number;
+    xmax?: number;
+    ymax?: number;
+    paths?: number[][][];
+    rings?: number[][][];
+    points?: number[][];
+    spatialReference?: {
+        wkid: number;
+        latestWkid?: number;
+    };
+}
+export interface Bounds {
+    _southWest: {
+        lat: number;
+        lng: number;
+    };
+    _northEast: {
+        lat: number;
+        lng: number;
+    };
+}
+/**
+ * Query task for ArcGIS Feature Services
+ * Based on Esri Leaflet's Query functionality
+ */
+export declare class Query extends Task {
+    protected setters: {
+        offset: string;
+        limit: string;
+        fields: string;
+        precision: string;
+        featureIds: string;
+        returnGeometry: string;
+        returnM: string;
+        transform: string;
+        token: string;
+    };
+    protected path: string;
+    protected params: Record<string, unknown>;
+    constructor(options: string | QueryOptions | Service);
+    /**
+     * Returns a feature if its shape is wholly contained within the search geometry
+     */
+    within(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if any spatial relationship is found
+     */
+    intersects(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if its shape wholly contains the search geometry
+     */
+    contains(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if the intersection of the interiors is not empty and has lower dimension
+     */
+    crosses(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if the two shapes share a common boundary
+     */
+    touches(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if the intersection results in same dimension but different from both shapes
+     */
+    overlaps(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Returns a feature if the envelope of the two shapes intersects
+     */
+    bboxIntersects(geometry: QueryGeometry | unknown): Query;
+    /**
+     * Nearby search - only valid for ArcGIS Server 10.3+ or ArcGIS Online
+     */
+    nearby(latlng: {
+        lat: number;
+        lng: number;
+    }, radius: number): Query;
+    /**
+     * Set WHERE clause for the query
+     */
+    where(whereClause: string): Query;
+    /**
+     * Set time range for temporal queries
+     */
+    between(start: Date | number, end: Date | number): Query;
+    /**
+     * Simplify geometries based on map resolution
+     */
+    simplify(map: {
+        getBounds(): Bounds;
+        getSize(): {
+            x: number;
+            y: number;
+        };
+    }, factor: number): Query;
+    /**
+     * Set order by fields
+     */
+    orderBy(fieldName: string, order?: 'ASC' | 'DESC'): Query;
+    /**
+     * Set specific layer to query (for Map Services)
+     */
+    layer(layerId: number): Query;
+    /**
+     * Return only distinct values
+     */
+    distinct(): Query;
+    /**
+     * Set pixel size for image services
+     */
+    pixelSize(point: {
+        x: number;
+        y: number;
+    }): Query;
+    /**
+     * Execute the query and return features
+     */
+    run(): Promise<GeoJSON.FeatureCollection>;
+    /**
+     * Execute the query and return only the count
+     */
+    count(): Promise<number>;
+    /**
+     * Execute the query and return only feature IDs
+     */
+    ids(): Promise<number[]>;
+    /**
+     * Execute the query and return extent bounds (ArcGIS Server 10.3+)
+     */
+    bounds(): Promise<{
+        _southWest: {
+            lat: number;
+            lng: number;
+        };
+        _northEast: {
+            lat: number;
+            lng: number;
+        };
+    }>;
+    private _setGeometryParams;
+    private _setGeometry;
+    private _cleanParams;
+    private _convertToGeoJSON;
+}
+export declare function query(options: string | QueryOptions): Query;
+export default query;