@conterra/ct-mapapps-typings 4.13.1 → 4.13.2-PRE-1

package/map-widget/MapWidgetFactory.d.ts

@@ -1,14 +1,12 @@
-export default MapWidgetFactory;
+/// <reference types="arcgis-js-api" />
+import Map from "esri/Map";
+import { MapWidgetFactory as MapWidgetFactoryInterface, MapWidgetModel as MapWidgetModelInterface, MapWidget as MapWidgetInterface } from "./api";
 /**
  * Use the `map-widget.MapWidgetFactory` service and not this class.
- *
- * The MapWidgetFactory provides some methods to create the parts of a MapWidget.
- * Note: The goal of the factory is to reduce the import statements of map-widget/* classes.
- * @interface
- * @alias module:MapWidgetFactory
  */
-declare function MapWidgetFactory(): {
-    createMap: typeof createMap;
-    createWidgetModel: typeof createWidgetModel;
-    createWidget: typeof createWidget;
-};
+export declare class MapWidgetFactory implements MapWidgetFactoryInterface {
+    createMap(options: any): Map;
+    createWidgetModel(options: any): MapWidgetModelInterface;
+    createWidget(options: any): MapWidgetInterface;
+}
+export default MapWidgetFactory;

package/map-widget/MapWidgetModel.d.ts

@@ -1,12 +1,55 @@
-export default MapWidgetModel;
-/**
- * @class
- * The ViewModel of the MapWidget.
- * It provides access to state information of the MapWidget.
- * Note: Every MapWidget has it's own MapWidgetModel.
- *
- * @alias module:MapWidgetModel
- */
-declare const MapWidgetModel: import("apprt-core/Mutable").MutableConstructor<{
-    [x: string]: any;
+import Camera from "esri/Camera";
+import Extent from "esri/geometry/Extent";
+import TimeExtent from "esri/TimeExtent";
+import Point from "esri/geometry/Point";
+import SpatialReference from "esri/geometry/SpatialReference";
+import Map from "esri/Map";
+import Viewpoint from "esri/Viewpoint";
+import { MapWidgetModel as MapWidgetModelType, MapWidgetModelMembers, ViewMode } from "./api";
+import SceneView from "esri/views/SceneView";
+import MapView from "esri/views/MapView";
+declare const _viewReady: unique symbol;
+export declare const MapWidgetModelImpl: import("apprt-core/Mutable").MutableConstructor<{
+    map: Map;
+    viewmode: ViewMode;
+    view: MapView | SceneView | undefined;
+    width: number | undefined;
+    height: number | undefined;
+    zoom: number | undefined;
+    scale: number | undefined;
+    extent: Extent | undefined;
+    center: Point | undefined;
+    rotation: number | undefined;
+    viewpoint: Viewpoint | undefined;
+    camera: Camera | undefined;
+    padding: __esri.ViewPadding | undefined;
+    timeExtent: TimeExtent | undefined;
+    updating: boolean | undefined;
+    spatialReference: SpatialReference | undefined;
+    [_viewReady]: boolean | undefined;
+    ready: boolean | undefined;
+    initialExtent: Extent | undefined;
+    initialViewParameters: Record<string, any> | undefined;
+    initialViewMode: ViewMode | undefined;
+    constraints: import("apprt-core/Mutable").Mutable<{
+        rotationEnabled: boolean;
+        snapToZoom: boolean;
+        minScale: number;
+        maxScale: number;
+        minZoom: number;
+        maxZoom: number;
+        geometry: any;
+        lods: null | undefined;
+        altitude: __esri.SceneViewConstraintsAltitudeProperties;
+        clipDistance: __esri.SceneViewConstraintsClipDistanceProperties;
+        tilt: __esri.SceneViewConstraintsTiltProperties;
+        forViewmode: (viewmode?: ViewMode | undefined) => Record<string, any>;
+    }>;
+    navigation: import("apprt-core/Mutable").Mutable<{
+        mouseWheelZoomEnabled: boolean;
+        browserTouchPanEnabled: boolean;
+    }>;
 }>;
+export declare const MapWidgetModel: new (args: Partial<MapWidgetModelMembers>) => MapWidgetModel;
+export declare type MapWidgetModel = MapWidgetModelType;
+export default MapWidgetModel;

package/map-widget/MapWidgetRegistration.d.ts

@@ -1,49 +1,14 @@
-export default MapWidgetRegistration;
-/**
- * @class
- * Please use the service `map-widget.MapWidgetRegistration`
- * and do not create an instance of this class manually!
- * @alias module:MapWidgetRegistration
- */
-declare function MapWidgetRegistration(): {
+/// <reference types="arcgis-js-api" />
+import type Map from "esri/Map";
+import type { MapWidget, MapWidgetModel, MapWidgetRegistration as MapWidgetRegistrationInterface } from "./api";
+export declare class MapWidgetRegistration implements MapWidgetRegistrationInterface {
+    #private;
     activate(componentContext: any): void;
     deactivate(): void;
-    /**
-     * Register the new default map widget. If one was previously registered, then it is unregistered.
-     *
-     * Following services are registered:
-     *
-     * * map-widget.MapWidgetModel
-     *     * the map widget model provided to interact with the main map
-     * * map-widget.Map
-     *     * the esri/Map part of the MapWidgetModel, provided if only the layer tree should change
-     * * map-widget.MapWidget
-     *     * the map widget, do not use it directly
-     *
-     * @param {Object} components components to register `{ map, mapWidgetModel, mapWidget }`
-     * @returns {undefined}
-     * @memberOf module:MapWidgetRegistration#
-     * @example
-     * let mapregistration = this._mapregistration;
-     * let mapfactory = this._mapfactory;
-     * let map = mapfactory.createMap({...});
-     * let model = mapfactory.createWidgetModel({map, ...});
-     * let widget = mapfactory.createWidget({model});
-     * mapregistration.register({
-     *      map : map,
-     *      mapWidgetModel : model,
-     *      mapWidget: widget
-     * });
-     */
-    register({ map, mapWidgetModel, mapWidget }: Object): undefined;
-    /**
-     * Unregister all services.
-     *
-     * @param {boolean} keepInstances suppress the destruction of widgets.
-     * @returns {undefined}
-     * @memberOf module:MapWidgetRegistration#
-     */
-    unregister(keepInstances: boolean): undefined;
-};
-declare class MapWidgetRegistration {
+    register({ map, mapWidgetModel, mapWidget }: {
+        map?: Map | undefined;
+        mapWidgetModel?: MapWidgetModel | undefined;
+        mapWidget: MapWidget;
+    }): void;
+    unregister(keepInstances: boolean): void;
 }

package/map-widget/Navigation.d.ts

@@ -1,10 +1,7 @@
-export default Navigation;
-/**
- * @class
- * A class representing the map navigation settings for a view.
- * @alias module:Navigation
- */
-declare const Navigation: import("apprt-core/Mutable").MutableConstructor<{
-    mouseWheelZoomEnabled: boolean | undefined;
-    browserTouchPanEnabled: boolean | undefined;
+import { Navigation as NavigationType } from "./api";
+export declare const Navigation: import("apprt-core/Mutable").MutableConstructor<{
+    mouseWheelZoomEnabled: boolean;
+    browserTouchPanEnabled: boolean;
 }>;
+export declare type Navigation = NavigationType;
+export default Navigation;

package/map-widget/OfflineBasemapDefinitionFilter.d.ts

@@ -1,2 +1 @@
-export default rewrite;
-declare function rewrite(definitions: any): void;
+export declare function rewrite(definitions: any): void;

package/map-widget/ScaleToolRuleProcessor.d.ts

@@ -1,6 +1,11 @@
-export default function ScaleToolRuleProcessor(): {
+import { InjectedReference } from "apprt-core/InjectedReference";
+import { MapWidgetModel } from "./api";
+export declare class ScaleToolRuleProcessor {
+    #private;
     ruleProperties: string[];
+    _mapWidgetModel: InjectedReference<MapWidgetModel>;
+    _ruleContextState: InjectedReference<Record<string, any>>;
     activate(): void;
-    isRuleFulfilled(tool: any, context: any, rule: any): boolean | never[] | undefined;
     deactivate(): void;
-};
+    isRuleFulfilled(tool: any, context: any, rule: any): boolean | [] | undefined;
+}

package/map-widget/SrsChangeService.d.ts

@@ -1,30 +1,11 @@
-export default SrsChangeService;
-/**
- * The SrsChangeService provides methods for successful switching of SRS on a MapWidget.
- * Inject this service via 'map-widget.SrsChangeService'.
- *
- * Note: this service is used by the sdi extension to provide the SRS toggle UI.
- *
- * @alias module:SrsChangeService
- */
-declare class SrsChangeService {
-    /**
-     * Resolves title of srs. An empty string is returned if no title can be resolved.
-     * @param {type} srsOrWkId
-     * @returns {String} title of srs or empty string if not found.
-     */
-    findTitleOfSRS(srsOrWkId: type): string;
-    /**
-     * Changes srs of default map widget.
-     * @param {esri/SpatialReference | number} srsOrWkId target srs
-     * @returns {Promise<map-widget/MapWidget>} the changed map widget
-     */
-    changeSRSOfDefaultMapWidgetTo(srsOrWkId: any): Promise<map>;
-    /**
-     * Changes srs of given map widget.
-     * @param {map-widget/MapWidget} mapWidget the MapWidget
-     * @param {esri/SpatialReference | number} srsOrWkId target srs
-     * @returns {Promise<map-widget/MapWidget>} the changed map widget
-     */
-    changeSRSOfMapWidgetTo(mapWidget: any, srsOrWkId: any): Promise<map>;
+/// <reference types="arcgis-js-api" />
+import SpatialReference from "esri/geometry/SpatialReference";
+import { MapWidget } from "./api";
+import { SrsChangeService as SrsChangeServiceInterface } from "./api/SrsChangeService";
+export declare class SrsChangeService implements SrsChangeServiceInterface {
+    private _mapWidget;
+    private _coordinateTransformer;
+    findTitleOfSRS(srsOrWkId: number | SpatialReference): string;
+    changeSRSOfDefaultMapWidgetTo(srsOrWkId: number | SpatialReference): Promise<MapWidget>;
+    changeSRSOfMapWidgetTo(mapWidget: MapWidget, srsOrWkId: number | SpatialReference): Promise<MapWidget>;
 }

package/map-widget/SubLayersInfo.d.ts

@@ -1,5 +1,48 @@
-export function findInfoOfSubLayer(subLayer: any): any;
-export function findSubLayerInfos(sublayerOrLayer: any): any;
+/// <reference types="arcgis-js-api" />
+import type Sublayer from "esri/layers/support/Sublayer";
+import type Layer from "esri/layers/Layer";
+import Extent from "esri/geometry/Extent";
+import { CustomFetch } from "apprt-fetch";
+declare const _loadingPromise: unique symbol;
+declare const _infos: unique symbol;
+export declare const SubLayerInfo: import("apprt-core/Mutable").MutableConstructor<{
+    id: number | undefined;
+    name: string | undefined;
+    description: string | undefined;
+    fields: never[] | undefined;
+    displayField: string | undefined;
+    objectKeyField: string | undefined;
+    extent: Extent | undefined;
+}>;
+export declare type SubLayerInfo = InstanceType<typeof SubLayerInfo>;
+export declare const SubLayersInfo: import("apprt-core/Mutable").MutableConstructor<{
+    url: string | undefined;
+    loading: boolean | undefined;
+    loaded: boolean | undefined;
+    __fetch: CustomFetch | undefined;
+    [_infos]: Record<string, import("apprt-core/Mutable").Mutable<{
+        id: number | undefined;
+        name: string | undefined;
+        description: string | undefined;
+        fields: never[] | undefined;
+        displayField: string | undefined;
+        objectKeyField: string | undefined;
+        extent: Extent | undefined;
+    }>>;
+    [_loadingPromise]: Promise<unknown> | undefined;
+    getIds: () => number[];
+    getById: (id: number) => import("apprt-core/Mutable").Mutable<{
+        id: number | undefined;
+        name: string | undefined;
+        description: string | undefined;
+        fields: never[] | undefined;
+        displayField: string | undefined;
+        objectKeyField: string | undefined;
+        extent: Extent | undefined;
+    }> | undefined;
+    load: () => Promise<unknown>;
+}>;
+export declare type SubLayersInfo = InstanceType<typeof SubLayersInfo>;
 export default SubLayersInfo;
-/** @type {any} */
-declare const SubLayersInfo: any;
+export declare function findInfoOfSubLayer(subLayer: Sublayer): any;
+export declare function findSubLayerInfos(sublayerOrLayer: Sublayer | Layer): any;

package/map-widget/ViewModeToolRuleProcessor.d.ts

@@ -1,7 +1,9 @@
-export default ViewModeToolRuleProcessor;
-declare function ViewModeToolRuleProcessor(): {
+export declare class ViewModeToolRuleProcessor {
+    #private;
     ruleProperties: string[];
+    private _ruleContextState;
+    private _model;
     activate(): void;
-    isRuleFulfilled(tool: any, ctx: any, rules: any): boolean | never[] | undefined;
     deactivate(): void;
-};
+    isRuleFulfilled(tool: any, ctx: any, rules: any): [] | boolean | undefined;
+}

package/map-widget/ViewParameterResolver.d.ts

@@ -1,6 +1,11 @@
-export default ViewParameterResolver;
-/**
- * TODO (typescript migration)
- * @type {any}
- */
-declare const ViewParameterResolver: any;
+import { MapWidgetModel, SrsChangeService } from "./api";
+import { ParameterValue, EncodedParameterValue } from "parametermanager/api";
+export declare const ViewParameterResolver: import("apprt-core/Mutable").MutableConstructor<{
+    _mapWidgetModel: MapWidgetModel | undefined;
+    _srsChanger: SrsChangeService | undefined;
+    useShortformForEncoding: boolean | undefined;
+    numDecimalPlaces: number | undefined;
+    encodeURLParameter: () => Record<string, EncodedParameterValue>;
+    decodeURLParameter: (params: Record<string, ParameterValue>) => void;
+    _applyState: () => void;
+}>;

package/map-widget/ViewProvider.d.ts

@@ -1,7 +1,23 @@
-export default provide;
-declare function provide({ mode, options }: {
-    mode?: string | undefined;
-    options?: {} | undefined;
-}): import("../../../apprt/apprt-core/Promise").ExtendedPromise<{
-    view: any;
+/// <reference types="arcgis-js-api" />
+import type MapView from "esri/views/MapView";
+import type SceneView from "esri/views/SceneView";
+import { ExtendedPromise } from "apprt-core/Promise";
+interface Provide2dParams {
+    mode: "2D";
+    options: __esri.MapViewProperties;
+}
+interface Provide3dParams {
+    mode: "3D";
+    options: __esri.SceneViewProperties;
+}
+declare type ProvideParams = Provide2dParams | Provide3dParams;
+export declare function provideView(params: Partial<Provide2dParams>): ExtendedPromise<{
+    view: MapView;
 }>;
+export declare function provideView(params: Partial<Provide3dParams>): ExtendedPromise<{
+    view: SceneView;
+}>;
+export declare function provideView(params: Partial<ProvideParams>): ExtendedPromise<{
+    view: MapView | SceneView;
+}>;
+export default provideView;

package/map-widget/ViewReadyWatcher.d.ts

@@ -1,7 +1,13 @@
-export default function ViewReadyWatcher(model: any): {
-    readonly mapWidgetModel: any;
-    addOnly(callback: any): any;
-    add(callback: any): any | undefined;
-    clear(): any;
+import type { MapWidgetModel } from "./api";
+export declare type ViewReadyCallback = (event: {
+    mapWidgetModel: MapWidgetModel;
+}) => void;
+export interface ViewReadyWatcher {
+    readonly mapWidgetModel: MapWidgetModel | undefined;
     destroy(): void;
-};
+    addOnly(callback: ViewReadyCallback): this;
+    add(callback: ViewReadyCallback): this;
+    clear(): void;
+}
+export declare function createViewReadyWatcher(model: MapWidgetModel): ViewReadyWatcher;
+export default createViewReadyWatcher;

package/map-widget/WebMapLoadingVerification.d.ts

@@ -1,4 +1,6 @@
-export default WebMapLoadingVerification;
-declare function WebMapLoadingVerification(): {
+export declare class WebMapLoadingVerification {
+    private _map;
+    private _i18n;
+    private _logger;
     activate(): void;
-};
+}

package/map-widget/api/Constraints.d.ts

@@ -0,0 +1,109 @@
+/// <reference types="arcgis-js-api" />
+import type { Mutable } from "apprt-core/Mutable";
+import type { Extent, Polygon } from "esri/geometry";
+import type LOD from "esri/layers/support/LOD";
+import type { ViewMode } from "./MapWidgetModel";
+/**
+ * Documentation for instances of {@link Constraints}.
+ */
+export interface ConstraintsMembers {
+    /**
+     * Indicates whether the user can rotate the map. Only valid for 2D.
+     */
+    rotationEnabled: boolean;
+    /**
+     * When true, the view snaps to the next LOD when zooming in or out. When false, the zoom is continuous. Only valid
+     * for 2D.
+     */
+    snapToZoom: boolean;
+    /**
+     * The minimum scale the user is allowed to zoom to within the view. Only valid for 2D.
+     */
+    minScale: number;
+    /**
+     * The maximum scale the user is allowed to zoom to within the view. Only valid for 2D.
+     */
+    maxScale: number;
+    /**
+     * The minimum zoom level the user is allowed to zoom to within the view. Only valid for 2D.
+     */
+    minZoom: number;
+    /**
+     * The maximum zoom level the user is allowed to zoom to within the view. Only valid for 2D.
+     */
+    maxZoom: number;
+    /**
+     * The area in which the user is allowed to navigate laterally. Only Extent and Polygon geometry types are supported
+     */
+    geometry: Extent | Polygon | __esri.ExtentProperties | __esri.PolygonProperties | null | undefined;
+    /**
+     * An array of LODs. If not specified, this value is read from the Map. Only valid for 2D.
+     */
+    lods: (LOD | __esri.LODProperties)[] | null | undefined;
+    /**
+     * Specifies a constraint on the minimum and maximum allowed camera altitude. Only valid for 3D.
+     *
+     * @example
+     * ```js
+     * constraints.altitude = {
+     *   // The minimum allowed camera altitude (in meters).
+     *   min: 1000,
+     *   // The maximum allowed camera altitude (in meters).
+     *   max: 100000
+     * }
+     * ```
+     */
+    altitude: __esri.SceneViewConstraintsAltitudeProperties;
+    /**
+     * Specifies the near and far webgl clip distances. Only valid for 3D.
+     *
+     * @example
+     * ```js
+     * constraints.clipDistance  = {
+     *   // The near clip distance.
+     *   near: 100,
+     *
+     *   // The far clip distance.
+     *   far: 1000,
+     *
+     *   // Specifies the mode of the constraint which is either auto or manual.
+     *   // In auto mode, the near and far clip distance values are automatically determined.
+     *   // In manual mode, the near and far clip distance values are user defined.
+     *   mode: "manual"
+     * }
+     * ```
+     */
+    clipDistance: __esri.SceneViewConstraintsClipDistanceProperties;
+    /**
+     * Specifies a constraint on the amount of allowed tilting of the view. Only valid for 3D.
+     *
+     * @example
+     * ```js
+     * constraints.tilt  = {
+     *   // Specifies the maximum amount of tilt (in degrees) allowed in the view and may range from 0.5 to 179.5
+     *   // degrees.
+     *   max: 100,
+     *
+     *   // Specifies the mode of the constraint.
+     *   // There are two possible values: auto or manual.
+     *   // In auto mode, the maximum tilt value is automatically determined based on the altitude of the view camera.
+     *   // In manual mode, the maximum tilt value is a user defined.
+     *   mode: "manual"
+     * }
+     * ```
+     */
+    tilt: __esri.SceneViewConstraintsTiltProperties;
+    /**
+     * Query the constraints for a specified viewmode, that are not undefined.
+     * @param viewmode The viewmode to get the constraints for. If empty, "2D" is assumed.
+     * @returns the constraint values
+     */
+    forViewmode(viewmode?: ViewMode): Record<string, any>;
+}
+/**
+ * A class representing constraints for a view.
+ * It can be queried for the constraints of a specified view mode, that are not undefined
+ *
+ * See {@link ConstraintsMembers} for documentation of members.
+ */
+export declare type Constraints = Mutable<ConstraintsMembers>;

package/map-widget/api/MapWidget.d.ts

@@ -0,0 +1,9 @@
+import { MapWidgetModel } from "./MapWidgetModel";
+/**
+ * The MapWidget shows a map. It is using the MapWidgetModel for state management.
+ * It should not be accessed directly by custom code, please use the MapWidgetModel instead!
+ */
+export interface MapWidget {
+    get(key: "model"): MapWidgetModel | undefined;
+    set(key: "model", value: MapWidgetModel | undefined): void;
+}

package/map-widget/api/MapWidgetFactory.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="arcgis-js-api" />
+import type Map from "esri/Map";
+import type { MapWidget } from "./MapWidget";
+import type { MapWidgetModel, MapWidgetModelMembers } from "./MapWidgetModel";
+/**
+ * Use the `map-widget.MapWidgetFactory` service to inject an instance of this interface.
+ *
+ * The MapWidgetFactory provides some methods to create the parts of a MapWidget.
+ */
+export interface MapWidgetFactory {
+    /**
+     * Creates a esri/Map instance.
+     *
+     * @param options options of the esri/Map constructor.
+     * @returns the new map instance.
+     * @see [Map](https://developers.arcgis.com/javascript/latest/api-reference/esri-Map.html)
+     */
+    createMap(options: __esri.MapProperties): Map;
+    /**
+     * Creates a MapWidgetModel instance.
+     *
+     * Note: in options the `map` parameter is required and needs to be a `esri/Map` instance.
+     *
+     * @param options options of the MapWidgetModel constructor.
+     * @returns the MapWidgetModel instance.
+     */
+    createWidgetModel(options: Partial<MapWidgetModelMembers> & {
+        map: Map;
+    }): MapWidgetModel;
+    /**
+     * Creates a MapWidget instance.
+     *
+     * @param options options of the MapWidget constructor.
+     * @returns the MapWidget instance.
+     */
+    createWidget(options: unknown): MapWidget;
+}