@conterra/ct-mapapps-typings 4.19.2-next.20250402042452 → 4.19.2-next.20250403042107

package/ct/tools/Tool.d.ts

@@ -27,209 +27,207 @@
  *
  * @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 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 | '*'>(
+    watch: <Prop extends keyof T | "*">(
         property: Prop,
-        handler: (...args: WatchCallbackParams<T, Prop extends '*' ? keyof T : Prop>) => void
-    ) => void
+        handler: (...args: WatchCallbackParams<T, Prop extends "*" ? keyof T : Prop>) => void
+    ) => void;
 
-    set: <Prop extends keyof T>(
-        property: Prop,
-        value: T[Prop]
-    ) => void
+    set: <Prop extends keyof T>(property: Prop, value: T[Prop]) => void;
 
-    get: <Prop extends keyof T>(
-        property: Prop
-    ) => T[Prop]
+    get: <Prop extends keyof T>(property: Prop) => T[Prop];
 };
 
 /** Placeholder type for parameters to all the Evented functions. */
-type Event = unknown;
+type UnknownEvent = unknown;
 
 /** Utility type for all the handler functions in Tool. */
-type HandlerFn<This, Event, Result> = ((this: This, event: Event) => Result) | undefined;
+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
+    id: string;
     /**
      * The title of the tool.
      */
-    title: string | undefined
+    title: string | undefined;
     /**
      * A description of the tool.
      */
-    description: string | undefined
+    description: string | undefined;
     /**
      * A tool tip.
      */
-    tooltip: string | undefined
+    tooltip: string | undefined;
     /**
      * The tooltip positions.
      * e.g. ["above","below","after","before"]
      */
-    tooltipPositions: ("above" | "below" | "after" | "before")[] | undefined
+    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
+    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
+    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
+    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
+    iconClass: string;
     /**
      * The visible state of the tool.
      * On change the onShow/onHide events are fired.
      */
-    visibility: boolean
+    visibility: boolean;
     /**
      * The enabled state of the tool.
      * On change the onDisabled, onEnabled events are fired.
      */
-    enabled: boolean
+    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
+    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
+    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
+    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
+    tool: Tool;
     /**
      * Flag auto disables the tool if it becomes hidden.
      * default: true.
      */
-    disableOnHide: boolean
+    disableOnHide: boolean;
     /**
      * Flag auto enables the tool if it becomes visible.
      * default: true.
      */
-    enableOnShow: boolean
+    enableOnShow: boolean;
     /**
      * Flag auto deactivates the tool if it is disabled.
      * default: true.
      */
-    deactivateOnDisable: boolean
+    deactivateOnDisable: boolean;
     /**
      * Flag auto activates the tool if it is enabled.
      * default: false.
      */
-    activateOnEnable: boolean
+    activateOnEnable: boolean;
     /**
      * Flag auto enables the tool if set("active",true) is called.
      */
-    enableOnActivate: boolean
+    enableOnActivate: boolean;
     /**
      * The scope of the default handler functions.
      */
-    handlerScope: object | null
+    handlerScope: object | null;
     /**
      * The handler function called if the tool is clicked.
      */
-    clickHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    clickHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool is double clicked.
      */
-    dblClickHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    dblClickHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called before the onActivate event is fired.
      */
-    beforeActivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    beforeActivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool is activated.
      */
-    activateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    activateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called before the onDeactivate event is fired.
      */
-    beforeDeactivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    beforeDeactivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool is deactivated.
      */
-    deactivateHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    deactivateHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool becomes enabled.
      */
-    enabledHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    enabledHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool becomes disabled.
      */
-    disabledHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    disabledHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool becomes visible.
      */
-    showHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    showHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool becomes hidden.
      */
-    hideHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    hideHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool starts a processing task.
      */
-    processStartHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    processStartHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * The handler function called if the tool ends a processing task.
      */
-    processEndHandler: HandlerFn<ToolProperties["handlerScope"], Event, void>
+    processEndHandler: HandlerFn<ToolProperties["handlerScope"], UnknownEvent>;
     /**
      * Rules flag read by the toolrules bundle (optional).
      */
-    rules: object | null
+    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, Event, boolean>
+    activationConditionHandler: HandlerFn<
+        ToolProperties["activationConditionHandlerScope"] | Tool,
+        UnknownEvent,
+        boolean
+    >;
     /**
      * The scope of the activation condition handler function.
      */
-    activationConditionHandlerScope: object | null
+    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
+    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: Event): void;
+    click(evt: UnknownEvent): void;
     /**
      * Simulates a dbl click on the tool.
      */
-    dblClick(evt: Event): void;
+    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.
@@ -238,59 +236,59 @@ interface ToolProperties {
     /**
      * The onClick event
      */
-    onClick(event: Event): void;
+    onClick(event: UnknownEvent): void;
     /**
      * The onDoubleClick event
      **/
-    onDblClick(event: Event): void;
+    onDblClick(event: UnknownEvent): void;
     /**
      * The onInfoMessage event, transports a message from the backend to the tool widget.
      **/
-    onInfoMessage(event: Event): void;
+    onInfoMessage(event: UnknownEvent): void;
     /**
      * The onBeforeActivate event, it is called short before onActivate.
      **/
-    onBeforeActivate(event: Event): void;
+    onBeforeActivate(event: UnknownEvent): void;
     /**
      * The onActivate event
      **/
-    onActivate(event: Event): void;
+    onActivate(event: UnknownEvent): void;
     /**
      * The onDeactivate event
      **/
-    onDeactivate(event: Event): void;
+    onDeactivate(event: UnknownEvent): void;
     /**
      * The onBeforeDeactivate event, it is called short before onDeactivate.
      **/
-    onBeforeDeactivate(event: Event): void;
+    onBeforeDeactivate(event: UnknownEvent): void;
     /**
      * The onEnabled event, if the tool becomes enabled (available for pressing)
      **/
-    onEnabled(event: Event): void;
+    onEnabled(event: UnknownEvent): void;
     /**
      * The onDisabled event, if the tool becomes disabled (not available for pressing)
      **/
-    onDisabled(event: Event): void;
+    onDisabled(event: UnknownEvent): void;
     /**
      * The onShow event, if the tool becomes visible (allowed to show on screen)
      **/
-    onShow(event: Event): void;
+    onShow(event: UnknownEvent): void;
     /**
      * The onHide event, if the tool becomes hidden (not allowed to show on screen)
      **/
-    onHide(event: Event): void;
+    onHide(event: UnknownEvent): void;
     /**
      * `onProcessStart` is called when an external process is started
      */
-    onProcessStart(event: Event): void;
+    onProcessStart(event: UnknownEvent): void;
     /**
      * `onProcessEnd` is called when an external process is stopped
      */
-    onProcessEnd(event: Event): void;
+    onProcessEnd(event: UnknownEvent): void;
 }
 
 interface ToolConstructor {
-    new(props?: Partial<ToolProperties>): Tool;
+    new (props?: Partial<ToolProperties>): Tool;
 }
 
 type Tool = Stateful<ToolProperties>;
@@ -300,3 +298,4 @@ type Tool = Stateful<ToolProperties>;
 declare const Tool: ToolConstructor;
 
 export { Tool as default };
+export type { TooltipPosition };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conterra/ct-mapapps-typings",
-"version": "4.19.2-next.20250402042452",
+"version": "4.19.2-next.20250403042107",
     "description": "TypeDefinitions for ct-mapapps",
     "author": "conterra",
     "license": "Apache-2.0"