@conterra/ct-mapapps-typings 4.20.1 → 4.20.2

package/ct/tools/Tool.d.ts

@@ -1,3 +1,301 @@
-declare const _default: any;
+/*
+ * Copyright (C) con terra GmbH
+ */
 
-export { _default as default };
+/**
+ * Utility type to create more specific parameter typings for {@link Stateful.watch}'s callback.
+ *
+ * This allows us to make the types of the callback's value parameters
+ * dependent on the callback's name parameter. This way, handler code like
+ * the following is well-typed:
+ * ```ts
+ * let stateful: Stateful<{id: string, priority: number}>;
+ * stateful.watch('*', (name, oldValue, newValue) => {
+ *   if (name === 'id') {
+ *     // TypeScript can now infer that newValue is a string
+ *     console.log(newValue.substring(0, 4));
+ *   }
+ *   if (name === 'priority') {
+ *     // TypeScript can now infer that oldValue and newValue are numbers
+ *     console.log(newValue - oldValue);
+ *   }
+ * });
+ * ```
+ *
+ * This uses TypeScript's distributive behavior in conditional types to turn
+ * a union of properties into a union of tuples.
+ *
+ * @see https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
+ */
+type WatchCallbackParams<T, P extends keyof T> = P extends unknown ? [name: P, oldValue: T[P], newValue: T[P]] : never;
+
+type Stateful<T> = T & {
+    watch: <Prop extends keyof T | "*">(
+        property: Prop,
+        handler: (...args: WatchCallbackParams<T, Prop extends "*" ? keyof T : Prop>) => void
+    ) => { remove: () => void };
+
+    set: <Prop extends keyof T>(property: Prop, value: T[Prop]) => void;
+
+    get: <Prop extends keyof T>(property: Prop) => T[Prop];
+};
+
+/** Placeholder type for parameters to all the Evented functions. */
+type UnknownEvent = unknown;
+
+/** Utility type for all the handler functions in Tool. */
+type HandlerFn<This, Event, Result = void> = ((this: This, event: Event) => Result) | undefined;
+
+type TooltipPosition = "above" | "below" | "after" | "before";
+
+/** A partial copy of the declaration in ct/tools/Tool adapted for TypeScript. The types are mostly educated guesses. */
+interface ToolProperties {
+    /**
+     * Given tool id.
+     */
+    id: string;
+    /**
+     * The title of the tool.
+     */
+    title: string | undefined;
+    /**
+     * A description of the tool.
+     */
+    description: string | undefined;
+    /**
+     * A tool tip.
+     */
+    tooltip: string | undefined;
+    /**
+     * The tooltip positions.
+     * e.g. ["above","below","after","before"]
+     */
+    tooltipPositions: TooltipPosition[] | undefined;
+    /**
+     * Priority is used to ensure an ordering of tools.
+     * Tools with high priority are first, equal priority means sort by id.
+     */
+    priority: number;
+    /**
+     * A tool group this information is also added as css class to the root node of the created button or menu.
+     */
+    toolGroup: string;
+    /**
+     * A tool class appended to the root node of the created button or menu.
+     * Note that ctTool_${id} is always added
+     */
+    toolClass: string;
+    /**
+     * A tool icon class appended to the icon node of the created button or menu.
+     * Note that ctToolIcon_${id} is always added
+     */
+    iconClass: string;
+    /**
+     * The visible state of the tool.
+     * On change the onShow/onHide events are fired.
+     */
+    visibility: boolean;
+    /**
+     * The enabled state of the tool.
+     * On change the onDisabled, onEnabled events are fired.
+     */
+    enabled: boolean;
+    /**
+     * The active state of the tool, this is only of interest if the tool is togglable.
+     * On change the onActivate, onDeactivate events are fired.
+     */
+    active: boolean;
+    /**
+     * The togglable state of the tool, this marks that the tool can be toggled.
+     * It should be set in the constructor and the state value should never dynamically change.
+     */
+    togglable: boolean;
+    /**
+     * The processing state of the tool, this marks that the tool is currently processing something.
+     * The state is toggled by the fireProcess* methods and independent from any other state of the tool.
+     */
+    processing: boolean;
+    /**
+     * The self reference. Please see the ToolReference class to note that this property allows
+     * to handle a tool like a tool reference, which makes code expecting references to be used with tools directly.
+     */
+    tool: Tool;
+    /**
+     * Flag auto disables the tool if it becomes hidden.
+     * default: true.
+     */
+    disableOnHide: boolean;
+    /**
+     * Flag auto enables the tool if it becomes visible.
+     * default: true.
+     */
+    enableOnShow: boolean;
+    /**
+     * Flag auto deactivates the tool if it is disabled.
+     * default: true.
+     */
+    deactivateOnDisable: boolean;
+    /**
+     * Flag auto activates the tool if it is enabled.
+     * default: false.
+     */
+    activateOnEnable: boolean;
+    /**
+     * Flag auto enables the tool if set("active",true) is called.
+     */
+    enableOnActivate: boolean;
+    /**
+     * The scope of the default handler functions.
+     */
+    handlerScope: object | null;
+    /**
+     * The handler function called if the tool is clicked.
+     */
+    clickHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool is double clicked.
+     */
+    dblClickHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called before the onActivate event is fired.
+     */
+    beforeActivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool is activated.
+     */
+    activateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called before the onDeactivate event is fired.
+     */
+    beforeDeactivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool is deactivated.
+     */
+    deactivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool becomes enabled.
+     */
+    enabledHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool becomes disabled.
+     */
+    disabledHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool becomes visible.
+     */
+    showHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool becomes hidden.
+     */
+    hideHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool starts a processing task.
+     */
+    processStartHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * The handler function called if the tool ends a processing task.
+     */
+    processEndHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
+    /**
+     * Rules flag read by the toolrules bundle (optional).
+     */
+    rules: object | null;
+    /**
+     * The handler function called to check a condition before activating a togglable tool.
+     * The function has to return true if condition is fulfilled and false if not.
+     */
+    activationConditionHandler: HandlerFn<
+        ToolProperties["activationConditionHandlerScope"] | Tool,
+        UnknownEvent,
+        boolean
+    >;
+    /**
+     * The scope of the activation condition handler function.
+     */
+    activationConditionHandlerScope: object | null;
+    /**
+     * If true real click,check/uncheck,dblclick events are delegated async into the tool model,
+     * so that the browser event flow is not broken.
+     */
+    async: boolean;
+    /**
+     * Simulates a click on the tool.
+     * Please note that this does not change the active state.
+     * A client have to call set("active",true|false) to change the state.
+     */
+    click(evt: UnknownEvent): void;
+    /**
+     * Simulates a dbl click on the tool.
+     */
+    dblClick(evt: UnknownEvent): void;
+    /**
+     * Sends a info message to the tool. It simple fires the onInfoMessage() event.
+     * Such a message is normally produced in the backend, to indicate a "please click me" state on the tool.
+     */
+    infoMsg(msgObj: { message: string }): void;
+    /**
+     * The onClick event
+     */
+    onClick(event: UnknownEvent): void;
+    /**
+     * The onDoubleClick event
+     **/
+    onDblClick(event: UnknownEvent): void;
+    /**
+     * The onInfoMessage event, transports a message from the backend to the tool widget.
+     **/
+    onInfoMessage(event: UnknownEvent): void;
+    /**
+     * The onBeforeActivate event, it is called short before onActivate.
+     **/
+    onBeforeActivate(event: UnknownEvent): void;
+    /**
+     * The onActivate event
+     **/
+    onActivate(event: UnknownEvent): void;
+    /**
+     * The onDeactivate event
+     **/
+    onDeactivate(event: UnknownEvent): void;
+    /**
+     * The onBeforeDeactivate event, it is called short before onDeactivate.
+     **/
+    onBeforeDeactivate(event: UnknownEvent): void;
+    /**
+     * The onEnabled event, if the tool becomes enabled (available for pressing)
+     **/
+    onEnabled(event: UnknownEvent): void;
+    /**
+     * The onDisabled event, if the tool becomes disabled (not available for pressing)
+     **/
+    onDisabled(event: UnknownEvent): void;
+    /**
+     * The onShow event, if the tool becomes visible (allowed to show on screen)
+     **/
+    onShow(event: UnknownEvent): void;
+    /**
+     * The onHide event, if the tool becomes hidden (not allowed to show on screen)
+     **/
+    onHide(event: UnknownEvent): void;
+    /**
+     * `onProcessStart` is called when an external process is started
+     */
+    onProcessStart(event: UnknownEvent): void;
+    /**
+     * `onProcessEnd` is called when an external process is stopped
+     */
+    onProcessEnd(event: UnknownEvent): void;
+}
+
+interface ToolConstructor {
+    new (props?: Partial<ToolProperties>): Tool;
+}
+
+type Tool = Stateful<ToolProperties>;
+
+// Declaring a type and a variable of the same name is a technique used by
+// TypeScript's type declarations for standard library types such as Date.
+declare const Tool: ToolConstructor;
+
+export { Tool as default };
+export type { TooltipPosition };

package/dataform/package.json

@@ -1,5 +1,5 @@
 {
     "name": "dataform",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/dataview/package.json

@@ -1,5 +1,5 @@
 {
     "name": "dataview",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/domains-system/package.json

@@ -1,5 +1,5 @@
 {
     "name": "domains-system",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/editing/api.d.ts

@@ -1,22 +1,12 @@
-import Graphic from 'esri/Graphic';
-import FeatureLayer from 'esri/layers/FeatureLayer';
-import Editor from 'esri/widgets/Editor';
+import Graphic from '@arcgis/core/Graphic';
+import FeatureLayer from '@arcgis/core/layers/FeatureLayer';
+import Editor from '@arcgis/core/widgets/Editor';
 import { Action, ActionOptions, ActionItem } from 'map-actions/api';
 
-/**
- * Well known workflow ids.
- */
-type WellKnownWorkflow = NonNullable<__esri.EditorProperties["allowedWorkflows"]>;
 /**
  * Properties used to create an {@link Editor}.
  */
-type EditorProperties = Omit<__esri.EditorProperties, "allowedWorkflows"> & {
-    /**
-     * @deprecated since ArcGIS Maps SDK for JavaScript 4.29
-     * use {@link __esri.EditorProperties.visibleElements} instead;
-     */
-    allowedWorkflows?: WellKnownWorkflow[];
-};
+type EditorProperties = __esri.EditorProperties;
 /**
  * Extension point to access the editing widget or its configuration.
  */
@@ -69,4 +59,4 @@ interface StartEditingMapActionItem extends ActionItem {
     objectId: number;
 }
 
-export type { Editing, EditorInterceptor, EditorProperties, StartEditingMapAction, StartEditingMapActionItem, StartEditingMapActionOptions, WellKnownWorkflow };
+export type { Editing, EditorInterceptor, EditorProperties, StartEditingMapAction, StartEditingMapActionItem, StartEditingMapActionOptions };

package/editing/package.json

@@ -1,5 +1,5 @@
 {
     "name": "editing",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/esri-widgets/EsriDijit.d.ts

@@ -8,4 +8,5 @@ declare function createDijit<T extends EsriWidget>(esriWidget: T, extraOptions?:
     class?: string;
 }): EsriDijit<T>;
 
-export { type EsriDijit, createDijit, createDijit as default };
+export { createDijit, createDijit as default };
+export type { EsriDijit };

package/esri-widgets/package.json

@@ -1,5 +1,5 @@
 {
     "name": "esri-widgets",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/geojson/api.d.ts

@@ -1,16 +1,16 @@
-import Geometry from 'esri/geometry/Geometry';
+import Geometry from '@arcgis/core/geometry/Geometry';
 
 /**
- * Provides the means to transform between WKT strings, GeoJSON and `esri/Geometry` objects.
+ * Provides the means to transform between WKT strings, GeoJSON and `@arcgis/core/Geometry` objects.
  * Registered as service `geojson.Transformer`.
  */
 interface Transformer {
     /**
-     * Parses the given GeoJSON object to esri/Geometry.
+     * Parses the given GeoJSON object to @arcgis/core/Geometry.
      */
     geojsonToGeometry(geoJSON: Record<string, unknown>): Geometry;
     /**
-     * Converts an `esri/Geometry` into a GeoJSON object.
+     * Converts an `@arcgis/core/Geometry` into a GeoJSON object.
      */
     geometryToGeojson(geometry: Geometry): Record<string, unknown>;
     /**
@@ -22,11 +22,11 @@ interface Transformer {
      */
     geojsonToWKT(geoJSON: Record<string, unknown>): string;
     /**
-     * Parses a WKT string into an `esri/Geometry`.
+     * Parses a WKT string into an `@arcgis/core/Geometry`.
      */
     wktToGeometry(wkt: string): Geometry;
     /**
-     * Converts an `esri/Geometry` into a WKT string.
+     * Converts an `@arcgis/core/Geometry` into a WKT string.
      */
     geometryToWKT(geometry: Geometry): string;
 }

package/geojson/package.json

@@ -1,5 +1,5 @@
 {
     "name": "geojson",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/geometryservice/api.d.ts

@@ -1,34 +1,34 @@
-import { Geometry } from 'esri/geometry';
-import Point from 'esri/geometry/Point';
-import Polygon from 'esri/geometry/Polygon';
-import Polyline from 'esri/geometry/Polyline';
+import { GeometryUnion } from '@arcgis/core/unionTypes';
+import Point from '@arcgis/core/geometry/Point';
+import Polygon from '@arcgis/core/geometry/Polygon';
+import Polyline from '@arcgis/core/geometry/Polyline';
 
 /**
- * GeometryService delegates to methods defined in esri/rest/geometryService.
+ * GeometryService delegates to methods defined in @arcgis/core/rest/geometryService.
  */
 interface GeometryService {
     get url(): string;
     areasAndLengths(areasAndLengthsParameters: any, requestOptions?: any): Promise<any>;
     autoComplete(polygons: any, polylines: any, requestOptions?: any): Promise<Polygon[]>;
     buffer(bufferParameters: any, requestOptions?: any): Promise<Polygon[]>;
-    convexHull(geometries: any, requestOptions?: any): Promise<Geometry>;
+    convexHull(geometries: any, requestOptions?: any): Promise<GeometryUnion>;
     cut(geometries: any, cutter: any, requestOptions?: any): Promise<any>;
-    densify(densifyParameters: any, requestOptions?: any): Promise<Geometry[]>;
-    difference(geometries: any, geometry: any, requestOptions?: any): Promise<Geometry>;
+    densify(densifyParameters: any, requestOptions?: any): Promise<GeometryUnion[]>;
+    difference(geometries: any, geometry: any, requestOptions?: any): Promise<GeometryUnion[]>;
     distance(distanceParameters: any, requestOptions?: any): Promise<number>;
     fromGeoCoordinateString(params: any, requestOptions?: any): Promise<any>;
-    generalize(generalizeParameters: any, requestOptions?: any): Promise<Geometry[]>;
-    intersect(geometries: any, intersector: any, requestOptions?: any): Promise<Geometry[]>;
+    generalize(generalizeParameters: any, requestOptions?: any): Promise<GeometryUnion[]>;
+    intersect(geometries: any, intersector: any, requestOptions?: any): Promise<GeometryUnion[]>;
     labelPoints(polygons: any, requestOptions?: any): Promise<Point[]>;
     lengths(lengthsParameters: any, requestOptions?: any): Promise<any>;
-    offset(offsetParameters: any, requestOptions?: any): Promise<Geometry[]>;
-    project(projectParameters: any, requestOption?: any): Promise<Geometry[]>;
+    offset(offsetParameters: any, requestOptions?: any): Promise<GeometryUnion[]>;
+    project(projectParameters: any, requestOption?: any): Promise<GeometryUnion[]>;
     relation(relationParameters: any, requestOptions?: any): Promise<Polygon[]>;
-    reshape(geometry: any, reshaper: any, requestOptions?: any): Promise<Geometry>;
-    simplify(geometries: any, requestOptions?: any): Promise<Geometry[]>;
+    reshape(geometry: any, reshaper: any, requestOptions?: any): Promise<GeometryUnion>;
+    simplify(geometries: any, requestOptions?: any): Promise<GeometryUnion[]>;
     toGeoCoordinateString(params: any, requestOptions?: any): Promise<string[]>;
     trimExtend(trimExtendParameters: any, requestOptions?: any): Promise<Polyline[]>;
-    union(geometries: any, requestOptions?: any): Promise<Geometry>;
+    union(geometries: any, requestOptions?: any): Promise<GeometryUnion>;
     get units(): Record<string, any>;
 }
 

package/geometryservice/package.json

@@ -1,5 +1,5 @@
 {
     "name": "geometryservice",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/graphics/GraphicsBuilder.d.ts

@@ -1,4 +1,4 @@
-import Graphic from 'esri/Graphic';
+import Graphic from '@arcgis/core/Graphic';
 
 declare function GraphicsBuilder(): {
     createGraphic: ({ geometry, symbolLookupStrategy, context, attributes }: {

package/graphics/package.json

@@ -1,5 +1,5 @@
 {
     "name": "graphics",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/highlights/api.d.ts

@@ -1,6 +1,6 @@
-import Collection from 'esri/core/Collection';
-import Graphic from 'esri/Graphic';
-import esriSymbol from 'esri/symbols/Symbol';
+import Collection from '@arcgis/core/core/Collection';
+import Graphic from '@arcgis/core/Graphic';
+import esriSymbol from '@arcgis/core/symbols/Symbol';
 import { ViewMode, MapWidgetModel } from 'map-widget/api';
 export { ViewMode } from 'map-widget/api';
 
@@ -42,7 +42,7 @@ type GeometryType = string;
 /**
  * Properties for default symbols.
  * Properties must contain all properties required by
- * [esri/Symbol](https://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-Symbol.html)
+ * [@arcgis/core/Symbol](https://developers.arcgis.com/javascript/latest/api-reference/esri-symbols-Symbol.html)
  * and its derived classes.
  */
 type SymbolProperties = Record<string, any>;

package/highlights/package.json

@@ -1,5 +1,5 @@
 {
     "name": "highlights",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/integration-map/package.json

@@ -1,5 +1,5 @@
 {
     "name": "integration-map",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/managementlayout/package.json

@@ -1,5 +1,5 @@
 {
     "name": "managementlayout",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/map-actions/api.d.ts

@@ -1,12 +1,12 @@
 import { EventSource } from 'apprt-core/Events';
-import { Geometry } from 'esri/geometry';
+import { GeometryUnion } from '@arcgis/core/unionTypes';
 import { PopupTemplateDefinition } from 'popups/api';
 
 interface ActionItem {
     /** Arbitrary properties. */
     readonly [key: string]: unknown;
     /** Some actions require an item geometry in order to work. */
-    readonly geometry?: Geometry;
+    readonly geometry?: GeometryUnion;
 }
 /** Shape of the `options` parameter passed to an action. */
 interface ActionOptions {

package/map-actions/package.json

@@ -1,5 +1,5 @@
 {
     "name": "map-actions",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }

package/map-basemaps-api/BasemapItem.d.ts

@@ -1,15 +1,8 @@
 import { MutableConstructor } from 'apprt-core/Mutable';
 import { BasemapItem as BasemapItem$1 } from './api.js';
-import Basemap from 'esri/Basemap';
+import '@arcgis/core/Basemap';
 
-declare const BasemapItem: MutableConstructor<{
-    id: string;
-    title: string | undefined;
-    description: string | undefined;
-    basemap: Basemap | undefined;
-    thumbnailUrl: string | undefined;
-    viewmode: ("2D" | "3D") | undefined;
-}>;
+declare const BasemapItem: MutableConstructor<BasemapItem$1>;
 type BasemapItem = BasemapItem$1;
 
 export { BasemapItem, BasemapItem as default };

package/map-basemaps-api/BasemapsModel.d.ts

@@ -1,6 +1,6 @@
 import { BasemapsModelMembers, BasemapItem, BasemapItemProps, BasemapsModel as BasemapsModel$1 } from './api.js';
 import 'apprt-core/Mutable';
-import 'esri/Basemap';
+import '@arcgis/core/Basemap';
 
 declare const BasemapsModel: {
     new (options?: Partial<Omit<BasemapsModelMembers, "basemaps"> & {

package/map-basemaps-api/api.d.ts

@@ -1,5 +1,5 @@
 import { Mutable } from 'apprt-core/Mutable';
-import Basemap from 'esri/Basemap';
+import Basemap from '@arcgis/core/Basemap';
 
 /**
  * Documentation for the members of {@link BasemapsModel}.

package/map-basemaps-api/package.json

@@ -1,5 +1,5 @@
 {
     "name": "map-basemaps-api",
-    "version": "4.20.1",
+    "version": "4.20.2",
     "types": ""
 }