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

package/apprt-core/assignWithPrototype.d.ts

@@ -10,7 +10,7 @@
  * @param sources Objects from where the properties are read.
  * @returns the target
  * @example
- * ```js
+ * ```typescript
  * import assignWithPrototype from "apprt-core/assignWithPrototype";
  * let a = {x: 1, z: 1 };
  * let b = {x: 2, y: 1 };
@@ -30,20 +30,23 @@ declare function assignWithPrototype<T extends {}>(target: T, ...sources: Record
  * @param sources Objects from where the properties are read.
  * @returns the target
  * @example
- * ```js
- * import { assignWithPrototypeCustomized } from "apprt-core/assignWithPrototype";
- * const a = { x: 1, z: 1 };
- * const b = { x: 2, _calc() { } };
+ * ```typescript
+ * const a: any = { x: 1, z: 1 };
+ * const b = { x: 2, _calc() {} };
  * const c = { y: 2, _hidden: "test" };
- * const out = assignWithPrototypeCustomized(a,
- *    (target, name, value) => {
- *        if (name.startsWith("_")) {
- *            return;
- *        }
- *        target[name] = value;
- *    }, b, c);
- * a1 === a // -> true
- * a1 is {x:2, y: 2, z: 1}
+ * const a1 = assignWithPrototypeCustomized(
+ *     a,
+ *     (target, name, value) => {
+ *         if (name.startsWith("_")) {
+ *             return;
+ *         }
+ *         target[name] = value;
+ *     },
+ *     b,
+ *     c
+ * );
+ * a1 === a; // -> true
+ * // a1 is {x:2, y: 2, z: 1}
  * ```
  */
 declare function assignWithPrototypeCustomized<T extends {}>(target: T, assigner: (target: T, name: string, value: any) => void, ...sources: Record<string, any>[]): Record<string, any>;
@@ -55,13 +58,13 @@ declare function assignWithPrototypeCustomized<T extends {}>(target: T, assigner
  * @param sources Objects from where the properties are read.
  * @returns the target
  * @example
- * ```js
+ * ```ts
  * import assignRecursiveWithPrototype from "apprt-core/assignRecursiveWithPrototype";
- * let a = {x: 1, z: { a: 1 } };
- * let b = {x: 2, z: { b: 1 } };
- * let a1 = assignRecursiveWithPrototype(a,b);
- * a1 === a // -> true
- * a1 is {x:2, z: { a: 1, b: 1 }}
+ * const a: any = { x: 1, z: { a: 1 } };
+ * const b = { x: 2, z: { b: 1 } };
+ * const a1 = assignRecursiveWithPrototype(a, b);
+ * a1 === a; // -> true
+ * // a1 is {x:2, z: { a: 1, b: 1 }}
  * ```
  */
 declare function assignRecursiveWithPrototype<T extends {}>(target: T, ...sources: Record<string, any>[]): Record<string, any>;

package/apprt-core/async.d.ts

@@ -8,14 +8,14 @@ import './Promise.js';
  * @param args the arguments pushed to the callback during execution.
  * @returns the execution promise
  * @example
- * ```js
+ * ```ts
  * import async from "apprt-core/async";
  * // a sum function
- * let sum = (x,y)=> x + y;
- * // execute 3+4, 200msec later
- * async(sum,200,3,4)
- *    // result === 7
- *   .then(result => console.log(result));
+ * const sum = (x: number, y: number) => x + y;
+ * // execute 3 + 4, 200msec later
+ * const result = await async(sum, 200, 3, 4);
+ * // result === 7
+ * assert.equal(result, 7);
  * ```
  */
 declare function async<Args extends any[], Result>(callback: (...args: Args) => Result | PromiseLike<Result>, delay: number, ...args: Args): CancelablePromise<Result>;

package/apprt-core/base64.d.ts

@@ -8,7 +8,7 @@
  * @module
  *
  * @example Encode string to Base64
- * ```js
+ * ```ts
  * import { encodeBase64 } from "apprt-core/base64";
  *
  * const base64str = encodeBase64("hello world");
@@ -16,7 +16,7 @@
  * ```
  *
  * @example Decode Base64 string
- * ```js
+ * ```ts
  * import { decodeBase64 } from "apprt-core/base64";
  *
  * const str = decodeBase64("aGVsbG8gd29ybGQ=");

package/apprt-core/bindAsync.d.ts

@@ -14,23 +14,20 @@ type MethodNames<Scope> = string & keyof Methods<Scope>;
  * @returns the function which runs the cb async
  * @deprecated use apprt-core/async with plain functions instead
  * @example
- * ```js
+ * ```ts
  * import bindAsync from "apprt-core/bindAsync";
  * class Counter {
- *     constructor(){
- *        this.count = 0;
- *     }
- *     inc(){
- *          return ++this.count;
+ *     count = 0;
+ *     inc() {
+ *         return ++this.count;
  *     }
  * }
- *
- * let counter = new Counter();
- * let asyncInc = bindAsync(counter,"inc");
+ * const counter = new Counter();
+ * const asyncInc = bindAsync(counter, "inc");
  * // execute counter.inc() async
- * asyncInc()
- *    // result === 1
- *   .then(result => console.log(result));
+ * const result = await asyncInc();
+ * // result === 1
+ * console.log(result));
  * ```
  */
 declare function bindAsync<Scope, MethodName extends MethodNames<Scope>, Partials extends any[]>(scope: Scope, name: MethodName, delay?: number, ...partials: Partials): (...args: any[]) => Promise<unknown>;

package/apprt-core/clone.d.ts

@@ -8,11 +8,11 @@ import { Primitive } from './Types.js';
  * > Note: Cycles in `obj` are not supported for now.
  *
  * @example
- * ```js
+ * ```ts
  * import clone from "apprt-core/clone";
  *
- * let src = {x: 1, y: { a: 2 } };
- * let copy = clone(src);
+ * const src = {x: 1, y: { a: 2 } };
+ * const copy = clone(src);
  * src === copy // -> false
  * src.y === copy.y // -> false
  * copy.y.a // -> 2
@@ -71,27 +71,25 @@ type TransformFunc = (value: any, ctx: TransformContext) => any | symbol;
  *
  * @example simple clone
  *
- * ```js
+ * ```ts
  * import {transform} from "apprt-core/clone";
  * const input = { x: 1, c: {a: 1} };
  * const copyOfInput = transform(input);
  * ```
  *
  * @example transformation
- * ```js
+ * ```ts
  * import {transform} from "apprt-core/clone";
- * const input = { x: 1, c: {a: 1} };
- * const transformedCopy = transform(input, (value, ctx)=> {
- *    if (ctx.path[ctx.path.length-1]==="c")){
- *       // value is { a: 1 }
- *       // change c to be a number
- *       return value.a;
- *    }
- *    return value;
+ * const input = { x: 1, c: { a: 1 } };
+ * const transformedCopy = transform(input, (value, ctx) => {
+ *     if (ctx.path[ctx.path.length - 1] === "c") {
+ *         // value is { a: 1 }
+ *         // change c to be a number
+ *         return value.a;
+ *     }
+ *     return value;
  * });
- *
  * // -> transformedCopy === { x: 1, c: 1 }
- *
  * ```
  */
 declare function transform<Input = any, Output = Input>(value: Input, valueTransformer?: TransformFunc): Output;

package/apprt-core/comparators.d.ts

@@ -46,9 +46,9 @@ declare function createStringComparator(locale?: string, ignoreCase?: boolean, n
  * Factory to create a string comparator which compares strings respecting numeric parts of the given strings.
  * The comparator splits the input into string and numeric parts to compare them separately.
  * @example
- * ```js
+ * ```ts
  * const comparator = createStringWithNumberPartsComparator();
- * const values = ["a1", "a10", "a2", "b1, "a20", "a3"];
+ * const values = ["a1", "a10", "a2", "b1", "a20", "a3"];
  * values.sort(comparator);
  * assert.deepStrictEqual(["a1", "a2", "a3", "a10", "a20", "b1"], values);
  * ```
@@ -127,7 +127,7 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  * The function can then be used, for example, in calls to _Array.sort()_.
  *
  * @example _Sort by age, then by name_
- * ```js
+ * ```ts
  * const data = [
  *   { name: "B", age: 21 },
  *   { name: "A", age: 21 },
@@ -138,7 +138,7 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  * ```
  *
  * @example _Reverse sort order for a single field_
- * ```js
+ * ```ts
  * const data = [
  *   { name: "B", age: 21 },
  *   { name: "A", age: 21 },
@@ -148,7 +148,7 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  * ```
  *
  * @example _Compare array items using indices as field "names"_
- * ```js
+ * ```ts
  * const data = [
  *   [1, 2],
  *   [1, 3],
@@ -159,7 +159,7 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  * ```
  *
  * @example _Compare field values with a custom comparator_
- * ```js
+ * ```ts
  * const compare = (a, b) => b - a; // Some custom comparison logic
  * const data = [
  *   { value: 3 },
@@ -170,7 +170,7 @@ keyof ObjectType | AllFieldSpecObjects<ObjectType, keyof ObjectType>;
  * ```
  *
  * @example _Compare field values with a custom value picker_
- * ```js
+ * ```ts
  * const valuePicker = (a) => a.value ?? 0; // Some custom value lookup logic, e.g. default values
  * const data = [
  *   { value: 3 },

package/apprt-core/config.d.ts

@@ -82,9 +82,13 @@ interface WellknownConfigKeys {
      */
     "apprt-boot-loader-info": any;
     /**
-     * A global configured Enterprise-Portal URL.
+     * A globally configured Enterprise-Portal URL.
      */
     "arcgis-portal-url": string;
+    /**
+     * The globally configured ArcGIS API key.
+     */
+    "esri-api-key": string;
     /**
      * URL to the /agol/token endpoint of map.apps.
      * Which provides an technical user token to e.g. consume a geolocation service as anonymous app user.

package/apprt-core/delegate.d.ts

@@ -3,12 +3,12 @@
  * The proxy.prototype is set to the given `source` object.
  *
  * @example
- * ```js
- * let src = {x: 1};
- * let proxy = {
+ * ```ts
+ * const src = {x: 1};
+ * const proxy = {
  *     y: 2
  * };
- * let a = delegate(src, proxy);
+ * const a = delegate(src, proxy);
  * a === proxy // -> true
  * a.y // -> 2
  * a.x // -> 1
@@ -22,13 +22,13 @@ declare function delegate<SourceType extends object>(source: SourceType): Source
  * The proxy.prototype is set to the given `source` object.
  *
  * @example
- * ```js
- * let src = {x: 1};
- * let proxy = {
+ * ```ts
+ * const src = {x: 1};
+ * const proxy = {
  *     y: 2
  * };
- * let a = delegate(src, proxy);
- * a === proxy // -> true
+ * const a = delegate(src, proxy);
+ * a === proxy; // -> true
  * a.y // -> 2
  * a.x // -> 1
  * ```

package/apprt-core/deprecate.d.ts

@@ -2,7 +2,7 @@
  * Logs a deprecation warning.
  * Deprecation logs can be configured via `log-deprecations` flag.
  * @example
- * ```js
+ * ```ts
  * import deprecate from "apprt-core/deprecate";
  *
  * deprecate("ct/_string encodeHTML", "Use apprt-core/string-escape instead.");

package/apprt-core/equals.d.ts

@@ -6,7 +6,7 @@
  * * If `a` and `b` are arrays then both will be equal if all items are equal.
  *
  * @example
- * ```js
+ * ```ts
  * import { equal } from "apprt-core/equals";
  *
  * if (equal(a, b)) {
@@ -27,7 +27,7 @@ declare function equal(a: any, b: any): boolean;
  * * If `a` and `b` are arrays then both will be equal if all items are equal.
  *
  * @example
- * ```js
+ * ```ts
  * import { deepEqual } from "apprt-core/equals";
  *
  * if (deepEqual(a, b)){

package/apprt-core/freeze.d.ts

@@ -11,7 +11,7 @@ type DeepFrozen<T> = T extends Record<string | symbol, any> | any[] ? {
  * @param obj Object to freeze. Should be an object or an array, otherwise has on effect.
  * @returns Always returns `obj`.
  * @example
- * ```js
+ * ```ts
  * import freeze from "apprt-core/freeze";
  * let src = {x: 1, y: { a: 2 } };
  * let srcFrozen = freeze(src);

package/apprt-core/global.d.ts

@@ -3,7 +3,7 @@
  * This should be preferred over the 'window' key word.
  *
  * @example
- * ```js
+ * ```ts
  * import global from "apprt-core/global";
  * window === global // -> true in browsers
  * ```

package/apprt-core/join.d.ts

@@ -23,18 +23,21 @@ interface JoinError {
  * @param promises the promises to wait for.
  * @returns to wait for all promises to finish.
  * @example
- * ```js
+ * ```ts
  * import join from "apprt-core/join";
- * let a = fetch("test.json");
- * let b = fetch("test2.json");
- * join([a,b]).then(results => {
- *      let ajson = results[0];
- *      let bjson = results[1];
- *      ...
- * }, e => {
- *      // e.error => first of all errors
- *      // e.all => results, e.g. e.all[0] === result of ajson
- * ));
+ * const a = fetch("test.json");
+ * const b = fetch("test2.json");
+ *
+ * try {
+ *     const results = await join([a, b]);
+ *     const ajson = results[0];
+ *     const bjson = results[1];
+ * } catch (e) {
+ *     const joinError: JoinError = e;
+ *     // joinError.all => results, e.g. e.all[0] === result of ajson
+ *     // joinError.error => first of all errors
+ *     // joinError.errors => all errors
+ * }
  * ```
  */
 declare function join<T>(promises: (T | PromiseLike<T>)[]): CancelablePromise<T[]>;

package/apprt-core/load-css.d.ts

@@ -14,20 +14,20 @@ interface LoadCssResult {
  * Loads a css file and returns a Promise to support waiting for the load.
  *
  * @example
- * ```js
+ * ```ts
  * import loadCSS from "apprt-core/load-css";
  *
- * loadCSS(require.toUrl("./test.css")).then(function(result){
+ * loadCss(require.toUrl("./test.css")).then(function(result){
  *     // result.url = url of css
  *     // result.link = link created in head
  *     // css loaded
  * });
  * ```
  * @example
- * ```js
+ * ```ts
  * import loadCSS from "apprt-core/load-css";
  *
- * loadCSS([
+ * loadCss([
  *     require.toUrl("./a.css"),
  *     require.toUrl("./b.css")
  * ]).then(function(results){

package/apprt-core/load-js.d.ts

@@ -17,7 +17,7 @@ interface LoadJsOptions {
  * Loads a js file, by wrapping 'require' into a Promise.
  *
  * @example
- * ```js
+ * ```ts
  * import loadJS from "apprt-core/load-js";
  *
  * loadJS("esri/Map").then(function(Map){
@@ -25,13 +25,13 @@ interface LoadJsOptions {
  * });
  * ```
  * @example
- * ```js
+ * ```ts
  * import loadJS from "apprt-core/load-js";
  *
  * loadJS(["test/Class1","test/Class2"]).then(function(clazzes){
- *     let Class1 = clazzes[0];
- *     let Class2 = clazzes[1];
- *     ...
+ *     const Class1 = clazzes[0];
+ *     const Class2 = clazzes[1];
+ *     // ...
  * });
  * ```
  * @param clazzes class names to load.

package/apprt-core/promise-utils.d.ts

@@ -21,22 +21,22 @@ interface ManualPromise<T> {
 /**
  * @returns a ManualPromise which helps to separate a promise from the resolve/reject methods.
  * @example
- *  ```js
+ *  ```ts
  *  import { createManualPromise } from "apprt-core/promise-utils";
  *
- *   const manualPromise = createManualPromise();
+ *  const manualPromise = createManualPromise();
  *
- *   // the created promise
- *   const promise = manualPromise.promise;
+ *  // the created promise
+ *  const promise = manualPromise.promise;
  *
- *   // can be resolved by
- *   manualPromise.resolve("value");
+ *  // can be resolved by
+ *  manualPromise.resolve("value");
  *
- *   // or rejected by
- *   manualPromise.reject(new Error("error"));
+ *  // or rejected by
+ *  manualPromise.reject(new Error("error"));
  *
- *   // destructuring is allowed
- *   const {promise, resolve, reject} = createManualPromise();
+ *  // destructuring is allowed
+ *  const {promise, resolve, reject} = createManualPromise();
  *  ```
  */
 declare function createManualPromise<T>(): ManualPromise<T>;
@@ -44,25 +44,25 @@ declare function createManualPromise<T>(): ManualPromise<T>;
  * Helper to lazy update a promise and an associated value.
  *
  * @example
- *  ```js
- *   import { LazyValue } from "apprt-core/promise-utils";
+ *  ```ts
+ *  import { LazyValue } from "apprt-core/promise-utils";
  *
- *   const lazy = new LazyValue();
+ *  const lazy = new LazyValue();
  *
- *   // code which needs the value, has to use:
- *   const theValue = await lazy.promise;
+ *  // code which needs the value, has to use:
+ *  const theValue = await lazy.promise;
  *
- *   // code which like to update the value uses:
- *   lazy.value = "newValue";
+ *  // code which like to update the value uses:
+ *  lazy.value = "newValue";
  *
- *   // the value can updated several times.
- *   // with every update the promise is replaced
+ *  // the value can updated several times.
+ *  // with every update the promise is replaced
  *
- *   // this resets the value to not fulfilled
- *   // the promise will then block again.
- *   lazy.value = undefined;
+ *  // this resets the value to not fulfilled
+ *  // the promise will then block again.
+ *  lazy.value = undefined;
  *
- *   // NOTE: currently the promise can not be switched into an error state.
+ *  // NOTE: currently the promise can not be switched into an error state.
  *  ```
  */
 declare class LazyValue<T> {

package/apprt-core/propertyToSymbol.d.ts

@@ -5,7 +5,7 @@
  * @param name property name
  * @param symbol symbol instance
  * @example
- * ```js
+ * ```ts
  * import propertyToSymbol from "apprt-core/propertyToSymbol";
  *
  * const _config = Symbol("_config");

package/apprt-core/string-escape.d.ts

@@ -6,7 +6,7 @@
  * @param str String that should be encoded
  * @returns encoded String
  * @example
- * ```js
+ * ```ts
  * import escape from "../string-escape";
  *
  * let escapedHtml = escape("hello <b>World</b>");

package/apprt-core/string-pattern.d.ts

@@ -9,7 +9,7 @@
  * This is a replacement function for `ct/_string.stringPatternToRegExp`.
  *
  * @example
- * ```js
+ * ```ts
  * import { createRegexFromPattern } from "apprt-core/string-pattern";
  * const regex = createRegexFromPattern("foo*");
  * const match = regex.test("foobar"); // true

package/apprt-core/string-replace.d.ts

@@ -43,10 +43,10 @@ interface ReplaceOptions {
  * A replacement function to replace all `${key}` values in a given `template`.
  *
  * @example
- * ```js
+ * ```ts
  * import replace from "apprt-core/string-replace";
  *
- * let msg = replace("Say ${msg}",{msg: "hello" });
+ * const msg = replace("Say ${msg}",{msg: "hello" });
  * msg === "Say hello"; // true
  * ```
  * @param template the template string containing `${key}` expressions.
@@ -59,19 +59,19 @@ type StringReplacer = (template: string, values?: Record<string, any> | ValueRes
  * @param options options of replacement function
  * @returns string replacer function.
  * @example _Adjust options to change not found values_
- * ```js
+ * ```ts
  * import {customReplacer} from "apprt-core/string-replace";
  *
  * const replace = customReplacer({
  *     valueNotFound: ""
  * });
  *
- * let msg = replace("${name} says ${msg}",{msg: "hello" });
+ * const msg = replace("${name} says ${msg}",{msg: "hello" });
  * msg === " says hello"; // true
  * ```
  *
  * @example _Custom value lookup function_
- * ```js
+ * ```ts
  * import {customReplacer} from "apprt-core/string-replace";
  *
  * const replace = customReplacer({
@@ -79,7 +79,7 @@ type StringReplacer = (template: string, values?: Record<string, any> | ValueRes
  *     valueLookup: (key, values) => values[key]
  * });
  *
- * let msg = replace("Says ${msg}",{msg: "hello" });
+ * const msg = replace("Says ${msg}",{msg: "hello" });
  * msg === "Says hello"; // true
  * ```
  */
@@ -89,19 +89,19 @@ declare function customReplacer(options?: ReplaceOptions): StringReplacer;
  *
  * @example
  * _Replace `${key}` using object as key to value mapping_
- * ```js
+ * ```ts
  * import {replace} from "apprt-core/string-replace";
  *
- * let msg = replace("${name} says ${msg}", { msg: "hello" });
+ * const msg = replace("${name} says ${msg}", { msg: "hello" });
  * msg === "${name} says hello"; // true
  * ```
  *
  * @example
  * _Replacing `${key}` using custom value lookup function_
- * ```js
+ * ```ts
  * import {replace} from "apprt-core/string-replace";
  *
- * let msg = replace("${name} says ${msg}", (key) => key === "msg" ? "hello" : "");
+ * const msg = replace("${name} says ${msg}", (key) => key === "msg" ? "hello" : "");
  * msg === " says hello"; // true
  * ```
  *

package/apprt-core/url-utils.d.ts

@@ -5,7 +5,7 @@
  * Note: the returned string does *not* contain a leading "?"
  *
  * @example
- * ```js
+ * ```ts
  * import { objectToQuery } from "apprt-core/url-utils";
  * const query = objectToQuery({
  *     a: 1,
@@ -24,7 +24,7 @@ declare function objectToQuery(object?: Record<string, any | any[]>): string;
  * No transformation of the individual values is done, i.e. all values will be strings.
  *
  * @example
- * ```js
+ * ```ts
  * import { queryToObject } from "apprt-core/url-utils";
  * const object = queryToObject("a=1&b=2&b=3");
  * // object is { a: "1", b: ["2", "3"] }

package/apprt-core/when.d.ts

@@ -11,16 +11,16 @@ type ErrorCallback<Scope> = (this: Scope, error: any) => any;
  * @param scope this binding for the callbacks
  * @returns always produces a promise
  * @example
- * ```js
+ * ```ts
  * // use it as wrapper to get a promise
  * return when(thing).then((thing)=> doSomethingWithTheThing);
  * ```
  *
  * @example
- * ```js
+ * ```td
  * import when from "apprt-core/when";
  * // bind success and error handler from an object
- * var scope = {
+ * const scope = {
  *     counter : 0,
  *     ok() {
  *         ++this.counter;