@conterra/ct-mapapps-typings 4.18.4-next.20241007040658 → 4.18.4-next.20241008035341

package/agssearch/api.d.ts

@@ -8,7 +8,7 @@ import { AsyncStore } from 'store-api/api';
  *
  * @example
  * Use the service name `agssearch.AGSStoreFactory` to obtain a {@link AGSStoreFactory} reference for your component:
- * ```js
+ * ```json
  * "components": [
  *     {
  *         "name": "MyExampleComponent",
@@ -24,10 +24,11 @@ import { AsyncStore } from 'store-api/api';
  *
  * @example
  * Use the obtained {@link AGSStoreFactory} to create new store instances.
- *  ```js
- *  class MyExampleComponent {
+ *  ```ts
+ * class MyExampleComponent {
+ *     _storeFactory: InjectedReference<AGSStoreFactory>;
  *     async exampleMethod() {
- *         const store = await this._storeFactory.createStore({
+ *         const store = await this._storeFactory!.createStore({
  *             id: "my-new-store",
  *             layerId: "a-valid-layer-id"
  *             // or url: "https://example.com/some/FeatureServer"

package/apprt/event/EventConstants.d.ts

@@ -11,7 +11,7 @@ declare const _default: Readonly<{
      * property must not receive events. More precisely, the value of each
      * string must conform to the following grammar:
      *
-     * ```js
+     * ```
      * topic-description := '*' | topic ( '/*' )?
      * topic := token ( '/' token )*
      * ```

package/apprt-core/AsyncTask.d.ts

@@ -41,12 +41,11 @@ interface Task<Args extends any[] = [], Result = void> {
  * Wraps a callback into a task object which can be used to control the async execution of it.
  *
  * @example
- * ```js
+ * ```ts
  * import AsyncTask from "apprt-core/AsyncTask";
- * let task = AsyncTask(x => x * 200);
- * task.run(2).then((r)=> {
- *      console.log(r); //-> 400
- * });
+ * const task = AsyncTask(x => x * 200);
+ * const r = await task.run(2);
+ * assert.strictEqual(r, 400);
  * ```
  */
 declare function createTask<Args extends any[], Result>(callback: (...args: Args) => Result | PromiseLike<Result>): Task<Args, Result>;

package/apprt-core/BlockingTaskExecutor.d.ts

@@ -18,13 +18,11 @@ declare const _asyncTask: unique symbol;
  * The difference to the {@link TaskExecutor} is that it only uses macro tasks and that task executions can be tracked
  * by clients.
  * @example
- * ```js
- * import BlockingTaskExecutor from "apprt-core/BlockingTaskExecutor";
- * let executor = new BlockingTaskExecutor();
- * let task = function(){ doSomething(); };
+ * ```ts
+ * const executor = new BlockingTaskExecutor();
+ * const task = () => { doSomething(); }; // ... };
  * // execute the task if others pushed before are finished.
- * let promise = executor.push(task);
- * promise.then((result)=> {...});
+ * const result = await executor.push(task);
  * ```
  */
 declare class BlockingTaskExecutor {

package/apprt-core/CancelablePromise.d.ts

@@ -21,14 +21,15 @@ declare class CancelablePromise<T> extends ExtendedPromise<T> {
      * Creates Promise instances with "cancel" function.
      * @param executor function defined as (resolve,reject,onCancelled)=> \{\}
      * @example
-     * ```js
-     * let p = new CancelablePromise((resolve,reject,onCancelled)=>{
-     *      onCancelled(()=> // do stuff if cancelled);
-     *      ...
+     * ```ts
+     * const p = new CancelablePromise((resolve, reject, onCancelled) => {
+     *     onCancelled(() => {
+     *         doSomething();
+     *     });
      * });
      *
      * // grab cancel function for later cancellation
-     * let cancel = p.cancel;
+     * const cancel = p.cancel;
      *
      * // now cancel
      * cancel();

package/apprt-core/Events.d.ts

@@ -126,20 +126,20 @@ type EventIdentifier = string | symbol;
  * @param listener event listener
  * @returns handle with `remove` method
  * @example
- * ```js
+ * ```ts
  * // object as event channel
- * let channel = {};
+ * const channel = {};
  * // connect to event "changed"
- * on(channel,"changed",(msg)=> console.log(msg));
+ * on(channel, "changed", (msg)=> console.log(msg));
  *
  * // it is possible to register to multiple events using ','
- * on(channel,"changed,click",(msg)=> console.log(msg));
+ * on(channel, "changed,click", (msg)=> console.log(msg));
  *
  * // it is possible to register to any events using '*'
- * on(channel,"*",(msg)=> console.log(msg));
+ * on(channel, "*", (msg)=> console.log(msg));
  *
  * // on provides handle to unregister
- * let handle = on(channel,"changed",(msg)=> console.log(msg));
+ * const handle = on(channel, "changed", (msg)=> console.log(msg));
  * // unregister using "remove"
  * handle.remove();
  * ```
@@ -151,15 +151,15 @@ declare function on<T = unknown | undefined>(target: any, eventName: EventIdenti
  * @param eventName event name
  * @param event the event arguments
  * @example
- * ```js
+ * ```ts
  * // object as event channel
- * let channel = {};
+ * const channel = {};
  *
  * // connect to event "changed"
- * on(channel,"changed",(msg)=> console.log(msg));
+ * on(channel, "changed", (msg)=> console.log(msg));
  *
  * // fire changed event
- * emit(channel,"changed","my event msg");
+ * emit(channel, "changed", "my event msg");
  * ```
  */
 declare function emit<T = unknown>(target: any, eventName: EventIdentifier, ...event: [] | [T]): void;
@@ -169,15 +169,15 @@ declare function emit<T = unknown>(target: any, eventName: EventIdentifier, ...e
  * @param eventName event name
  * @param event the event arguments
  * @example
- * ```js
+ * ```ts
  * // object as event channel
- * let channel = {};
+ * const channel = {};
  *
  * // connect to event "changed"
- * on(channel,"changed",(msg)=> console.log(msg));
+ * on(channel, "changed", (msg)=> console.log(msg));
  *
  * // fire changed event
- * emitSync(channel,"changed","my event msg");
+ * emitSync(channel, "changed", "my event msg");
  * ```
  */
 declare function emitSync(target: any, eventName: EventIdentifier, ...event: [] | [unknown]): void;
@@ -185,12 +185,12 @@ declare function emitSync(target: any, eventName: EventIdentifier, ...event: []
  * Cleans any event channel created on the given target. Un-registers any event listener.
  * @param target the channel object.
  * @example
- * ```js
+ * ```ts
  * // object as event channel
- * let channel = {};
+ * const channel = {};
  *
  * // connect to event "changed"
- * on(channel,"changed",(msg)=> console.log(msg));
+ * on(channel, "changed", (msg)=> console.log(msg));
  *
  * // clean channel
  * cleanup(channel);
@@ -267,14 +267,16 @@ declare const Evented: EventedConstructor;
  * @param Base class to inherit from.
  * @returns class which inherits from `Base`.
  * @example
- * ```js
+ * ```ts
  * import { EventedMixin } from "apprt-core/Events";
  *
  * const MyClass = EventedMixin(class {
- *      trigger(){
- *          this.emit("changed");
- *      }
+ *     trigger() {
+ *         (this as any).emit("changed", true);
+ *     }
  * });
+ * const myClassInstance = new MyClass();
+ * myClassInstance.trigger();
  * ```
  */
 declare function EventedMixin<BaseType extends Constructor<any, any>>(Base: BaseType): Constructor<InstanceType<BaseType> & Evented<any>, ConstructorParameters<BaseType>>;

package/apprt-core/Exception.d.ts

@@ -17,15 +17,15 @@ interface BaseExceptionConstructor<ExceptionType, AllowedNames> {
  * Note: This should only be used by custom Exception classes. It is exported as extra name!
  *
  * @example
- * ```js
+ * ```ts
  *  import {default as Exception, registerTypes} from "apprt-core/Exception";
  *
- *  // register new exception type
- *  registerTypes(Exception, "ILLEGAL_STATE_ERROR");
- *  // now clients can invoke
- *  let e = Exception.illegalStateError("error message");
- *  e.name === 'ILLEGAL_STATE_ERROR'
- *  e.message === "error message"
+ * // register new exception type
+ * registerTypes(Exception, "ILLEGAL_STATE_ERROR");
+ * // now clients can invoke
+ * const e = Exception.illegalStateError("error message");
+ * e.name === 'ILLEGAL_STATE_ERROR';
+ * e.message === "error message";
  * ```
  * @param exceptionConstructor the exception constructor.
  * @param names the exception names to register.
@@ -56,7 +56,7 @@ interface Exception extends Error {
 /**
  * An Exception is a special error class to allow trees of causes.
  * @example
- * ```js
+ * ```ts
  * import Exception from "apprt-core/Exception";
  *
  * try {
@@ -77,7 +77,7 @@ interface ExceptionConstructor extends BaseExceptionConstructor<Exception, typeo
      * @param error the error
      * @param msg the error message
      * @example
-     * ```js
+     * ```ts
      * import Exception from "apprt-core/Exception";
      *
      * try {

package/apprt-core/Logger.d.ts

@@ -14,14 +14,14 @@ type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
  * [org.slf4j.Logger API](https://www.javadoc.io/doc/org.slf4j/slf4j-api/1.7.22/org/slf4j/Logger.html).
  *
  * @example <caption>Log debug message</caption>
- * ```js
+ * ```ts
  *   import { loggerForName } from "apprt-core/Logger";
  *   const LOG = loggerForName("mybundle/MyFile");
  *   LOG.debug("Component started");
  * ```
  *
  *  @example <caption>Use placeholders</caption>
- * ```js
+ * ```ts
  *   import { loggerForName } from "apprt-core/Logger";
  *   const LOG = loggerForName("mybundle/MyFile");
  *   const name = "Xyz";
@@ -30,7 +30,7 @@ type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
  * ```
  *
  * @example <caption>Test wether log level is enabled</caption>
- * ```js
+ * ```ts
  *   import { loggerForName } from "apprt-core/Logger";
  *   const LOG = loggerForName("mybundle/MyFile");
  *
@@ -40,7 +40,7 @@ type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR" | "OFF";
  * ```
  *
  * @example <caption>Log prefixed messages</caption>
- * ```js
+ * ```ts
  *   import { loggerForName } from "apprt-core/Logger";
  *   const LOG = loggerForName("mybundle/MyFile");
  *   const LOGWithPrefix = LOG.withPrefix("[my prefix]");
@@ -135,7 +135,7 @@ interface Logger {
      * Creates a new Logger, which will prefix each log message with the given prefix.
      *
      * @example <caption>Log prefixed messages</caption>
-     * ```js
+     * ```ts
      *   const LOG = loggerForName("mybundle/MyFile");
      *   const LOGWithPrefix = LOG.withPrefix("[my prefix]");
      *   LOGWithPrefix.info("My Message");
@@ -152,7 +152,7 @@ interface Logger {
  * @returns a logger instance. Returns the same logger instance for an equal logger name.
  *
  * @example <caption>Logger usage</caption>
- * ```js
+ * ```ts
  *  import { loggerForName } from "apprt-core/Logger";
  *  const LOG = loggerForName("mybundle/MyFile");
  *  LOG.info("Component started");
@@ -166,7 +166,7 @@ declare function loggerForName(name: string): Logger;
  * @param level the new level of the logger.
  *
  * @example <caption>Samples</caption>
- * ```js
+ * ```ts
  *  import {setLogLevel} from "apprt-core/Logger";
  *  // Changes the root level to DEBUG
  *  // All loggers without special configuration will now output messages.

package/apprt-core/Mutable.d.ts

@@ -170,18 +170,18 @@ declare const Mutable: MutableConstructor<any>;
  *
  * @param definition an object with a class specification.
  * @example
- * ```js
- * let Clazz = declare({
+ * ```ts
+ * const Clazz = declare({
  *     firstName: "",
  *     lastName: "",
  *     fullName: {
  *         depends: ["firstName", "lastName"],
- *         get() {
+ *         get(): string {
  *             return `${this.firstName} ${this.lastName}`;
  *         }
  *     }
  * });
- * var x = new Clazz();
+ * const x = new Clazz();
  * ```
  */
 declare function declare<Def extends MutableDefinition<any>>(definition: Def & {
@@ -191,18 +191,18 @@ declare function declare<Def extends MutableDefinition<any>>(definition: Def & {
  * Helper to declare Mutable classes from a specification. This is also the default export.
  * @param definition an object with a class specification.
  * @example
- * ```js
- * let Clazz = declare({
+ * ```ts
+ * const Clazz = declare({
  *     firstName: "",
  *     lastName: "",
  *     fullName: {
  *         depends: ["firstName", "lastName"],
- *         get() {
+ *         get(): string {
  *             return `${this.firstName} ${this.lastName}`;
  *         }
  *     }
  * });
- * var x = new Clazz();
+ * const x = new Clazz();
  * ```
  */
 declare function declare<Def extends MutableDefinition<any>>(definition: Def & ThisType<Mutable<BuildMutableMembers<Def>>>): MutableConstructor<BuildMutableMembers<Def>>;
@@ -212,26 +212,26 @@ declare function declare<Def extends MutableDefinition<any>>(definition: Def & T
  * @param instance the instance which property.
  * @param name the name of the changed property.
  * @example
- * ```js
- *  import {declare, notifyChange} from "apprt-core/Mutable";
- *  const globalCounter = 0;
- *  let Clazz = declare({
- *      counter: {
- *          get() {
- *              return globalCounter;
- *          }
- *      }
+ * ```ts
+ * import {declare, notifyChange} from "apprt-core/Mutable";
+ * let globalCounter = 0;
+ * const Clazz = declare({
+ *     counter: {
+ *         get() {
+ *             return globalCounter;
+ *         }
+ *     }
  * });
  *
- *  let instance = new Clazz();
- *  instance.watch("counter",({value})=>{
- *      console.log("count:"+value);
- *  })
+ * const instance = new Clazz();
+ * instance.watch("counter", ({ value }) => {
+ *     console.log(`count: ${value}`);
+ * });
  *
- *  // ensure that external counter can be watched
- *  globalCounter++;
- *  notifyChange(instance,"counter");
- *  //-> count: 1
+ * // ensure that external counter can be watched
+ * globalCounter++;
+ * notifyChange(instance, "counter");
+ * //-> count: 1
  * ```
  */
 declare function notifyChange<M extends Mutable<any>>(instance: M, name: PropertyName<M>): void;
@@ -241,15 +241,13 @@ declare function notifyChange<M extends Mutable<any>>(instance: M, name: Propert
  * @param skipOwn skip additional object property names that were not part of the original `declare()`.
  * @returns property names
  * @example
- * ```js
- * let Clazz = declare({
+ * ```ts
+ * const Clazz = declare({
  *     firstName: "",
- *     lastName: "",
+ *     lastName: ""
  * });
- *
- * let instance = new Clazz();
- *
- * let names = propertyNames(instance);
+ * const instance = new Clazz();
+ * const names = propertyNames(instance);
  * //-> names === ["firstName","lastName"]
  * ```
  */
@@ -260,15 +258,13 @@ declare function propertyNames(instance: Mutable<any>, skipOwn?: boolean): strin
  * @param instance the instance to introspect.
  * @returns values of all properties;
  * @example
- * ```js
- * let Clazz = declare({
+ * ```ts
+ * const Clazz = declare({
  *     firstName: "",
- *     lastName: "",
+ *     lastName: ""
  * });
- *
- * let instance = new Clazz({firstName:"Test"});
- *
- * let state = toObject(instance);
+ * const instance = new Clazz({firstName:"Test"});
+ * const state = toObject(instance);
  * //-> { firstName: "Test", lastName:"" }
  * ```
  */

package/apprt-core/Observable.d.ts

@@ -6,11 +6,11 @@ declare global {
  *
  * @deprecated the observable proposal is 'dead'
  * @example
- * ```js
+ * ```ts
  * // create observable, which ticks all 100 msec
- * var observable = new Observable(observer => {
+ * const observable = new Observable((observer: any) => {
  *     let counter = 0;
- *     let t = setInterval(() => {
+ *     const t = setInterval(() => {
  *         observer.next(++counter);
  *     }, 100);
  *     // return a cleanup function, is called if subscriber unsubscribes
@@ -18,10 +18,12 @@ declare global {
  *         clearInterval(t);
  *     };
  * });
- *
  * // now somebody can subscribe
- * var subscription = observable.subscribe({ next(value) { console.debug(value); } });
- *
+ * const subscription = observable.subscribe({
+ *     next(value: number) {
+ *         console.debug(value);
+ *     }
+ * });
  * // to unlink do:
  * subscription.unsubscribe();
  * ```

package/apprt-core/Observers.d.ts

@@ -121,66 +121,72 @@ interface ObserverOptions {
  * @param options optional parameters to customize the creation
  *
  * @example _track a event connection_
- * ```js
+ * ```ts
  * import Observers from "apprt-core/Observers";
- * let eventSource = new Evented();
- * let observers = Observers();
- * // track connection to eventSource
- * observers.add(eventSource.on("event", ()=>{...}));
+ * import { Evented } from "apprt-core/Events";
  *
+ * const eventSource = new Evented();
+ * const observers = Observers();
+ * // track connection to eventSource
+ * observers.add(eventSource.on("event", ()=>{ ... }));
  * // if the connection needs to be cleaned call
  * observers.clean();
  * ```
  *
  * @example _group event connections_
- * ```js
- * import Observers from "apprt-core/Observers";
- * let eventSourceA = new Evented();
- * let eventSourceB = new Evented();
- * let observers = Observers();
+ * ```ts
+ * const eventSourceA = new Evented();
+ * const eventSourceB = new Evented();
+ * const observers = Observers();
  * // track connection to eventSourceA, but in group "a"
  * observers.group("a").add(eventSourceA.on("event", ()=>{ ... }));
  * // track connection to eventSourceB, but in group "b"
  * observers.group("b").add(eventSourceB.on("event", ()=>{ ... }));
- *
  * // if "a" is not longer required
  * observers.group("a").clean();
- *
  * // if "b" is not longer required (shows alternative)
  * observers.clean("b");
- *
  * // if none of the connections are required anymore clean all
  * observers.clean();
  * ```
  *
  * @example _use the rebind functionality_
- * ```js
+ * ```ts
  * // The bind/rebind functionality helps to encapsulate the code to connect to an observable.
  * // When the observable target changes a simple call to 'bind'
  * // rexecutes the connection code and clears the old connection.
  *
- * import Observers from "apprt-core/Observers";
- * let Controller = class {
- *      constructor() {
- *          this.events = [];
- *          this._observers = Observers({
- *              // rebind is executed if Observers.bind is called, and used to reconnect to a new source instance
- *              rebind: (observers, source) => {
- *                  observers.add(source.on("change", (evt) => {
- *                      this.events.push(evt);
- *                  }));
- *              }
- *          });
- *      }
- *      connect(eventSource) {
+ * import createObservers, { Observers } from "apprt-core/Observers";
+ * import { Evented } from "apprt-core/Events";
+ *
+ * interface CustomEvents {
+ *     "changed": boolean
+ * }
+ *
+ * class Controller {
+ *     private observers: Observers | undefined;
+ *     private events: any[] = [];
+ *     constructor() {
+ *         this.events = [];
+ *         this.observers = createObservers({
+ *             // rebind is executed if Observers.bind is called, and used to reconnect to a new source instance
+ *             rebind: (observers, source) => {
+ *                 const eventSource = source as Evented<CustomEvents>;
+ *                 observers.add(eventSource.on("change", (evt) => {
+ *                     this.events.push(evt);
+ *                 }));
+ *             }
+ *         });
+ *     }
+ *     connect(eventSource: Evented<CustomEvents>) {
  *         // observe new event source
- *          this._observers.bind(eventSource);
- *      }
- *      disconnect() {
+ *         this.observers!.bind(eventSource);
+ *     }
+ *     disconnect() {
  *         // disconnect from event source
- *          this._observers.clean();
- *      }
- *  }
+ *         this.observers!.clean();
+ *     }
+ * }
  * ```
  */
 declare function createObservers(options?: ObserverOptions): Observers;

package/apprt-core/Promise.d.ts

@@ -29,8 +29,8 @@ declare class ExtendedPromise<T> implements Promise<T> {
      * Creates Promise instances.
      * @param executor defined as (resolve,reject)=> \{\}
      * @example
-     * ```js
-     * new Promise((resolve,reject)=>{
+     * ```ts
+     * new Promise((resolve, reject)=>{
      *      ...
      * });
      * ```
@@ -98,7 +98,7 @@ declare class ExtendedPromise<T> implements Promise<T> {
      * Allows to resolve/reject the promise manually after creating it.
      *
      * @example
-     * ```js
+     * ```ts
      * const { promise, resolve, reject } = Promise.withResolvers();
      * ```
      * @returns {{ promise, resolve, reject }}

package/apprt-core/TaskExecutor.d.ts

@@ -19,10 +19,10 @@ interface Task {
  * Implementation hint: Pushed task are queued and executed as micro tasks in the next event queue slot.
  *
  * @example _Use default export_
- * ```js
+ * ```ts
  * import TaskExecutor from "apprt-core/TaskExecutor";
- * let executor = new TaskExecutor();
- * let task = function(){ doSomething(); };
+ * const executor = new TaskExecutor();
+ * const task = function(){ doSomething(); };
  * // execute the task as fast as possible
  * executor.push(task);
  * // add again (will drop the old add, as long as the task was not executed)