@conterra/ct-mapapps-typings 4.13.2-next.20220701040636 → 4.13.2-next.20220704040728

package/agolauthn/AuthenticationPlugin.d.ts

@@ -6,7 +6,7 @@ export default class AGOLAuthenticationPlugin {
     _roleMapping: any;
     _organizationId: any;
     _fetchSelf: any;
-    _oauth: any;
+    _oauth: boolean | undefined;
     /**
      * @returns {Authentication} authentication instance
      */

package/agssearch/LayerStore.d.ts

@@ -10,7 +10,7 @@ export interface LayerStoreMetadata extends Metadata {
     /** Whether the store supports pagination or not. */
     readonly supportsPagination: boolean;
     /** Maximum number of features that can be requested from the server. */
-    readonly maxRecordCount: number;
+    readonly maxRecordCount: number | undefined;
 }
 declare type FeatureLayerProps = "type" | "destroy" | "load" | "loaded" | "url" | "layerId" | "capabilities" | "sourceJSON" | "objectIdField" | "title" | "displayField" | "geometryType" | "fullExtent" | "popupTemplate" | "fields" | "createQuery" | "queryObjectIds" | "queryFeatures" | "queryFeatureCount" | "definitionExpression";
 export declare type SimpleFeatureLayer = Pick<FeatureLayer, FeatureLayerProps>;

package/apprt-core/config-dojo.d.ts

@@ -1,4 +1,8 @@
-import { RegisterFunction } from "./config";
+import { RegisterOptions, ValueOrProvider } from "./config";
 import "dojo/_base/sniff";
+interface RegisterFunction<T> {
+    (key: keyof T, valueOrProvider: ValueOrProvider<T>, options?: RegisterOptions): void;
+}
 export declare function registerDojoConfigKey<T>(registerFn: RegisterFunction<T>, name: keyof T, path: string, dconfig?: any): void;
 export declare function registerHasKey<T>(registerFn: RegisterFunction<T>, name: keyof T): void;
+export {};

package/apprt-core/config.d.ts

@@ -138,7 +138,7 @@ export interface WellknownConfigKeys {
      * Url to a callback page which consumes the access token.
      * Only of interest if oauth-use-popup is true.
      */
-    "oauth-callback-page": string;
+    "oauth-popup-callback-page": string;
     /**
      * Flag to enforce a login,
      * Experimental, ignore that.
@@ -180,6 +180,9 @@ export interface WellknownConfigKeys {
 }
 /** Valid configuration property names. */
 export declare type ConfigKey = keyof WellknownConfigKeys;
+/**
+ * Lists well known environment property names and their types.
+ */
 export interface WellknownEnvKeys {
     /**
      * True if content security policy settings prevent eval() etc.
@@ -214,7 +217,7 @@ export interface WellknownEnvKeys {
      */
     "android": number;
 }
-/** Valid configuration property names. */
+/** Valid environment property names. */
 export declare type EnvKey = keyof WellknownEnvKeys;
 /** Supported value types. */
 export declare type SupportedValueTypes = undefined | null | boolean | number | string | SupportedValueTypes[] | {
@@ -222,25 +225,61 @@ export declare type SupportedValueTypes = undefined | null | boolean | number |
 };
 declare type ValueCallback<K, R> = (key: K) => R | undefined;
 declare type ValueOrCallback<K, R> = R | ValueCallback<K, R>;
+/**
+ * Type used by the register functions.
+ * To distinguish a plain value or a function providing the value.
+ */
 export declare type ValueOrProvider<T, K extends keyof T = keyof T> = ValueOrCallback<K, Extract<T[K], SupportedValueTypes>>;
-export declare type RegisterFunction<T, K extends keyof T = keyof T> = (n: K, valueOrProvider: ValueOrProvider<T, K>, cacheProvidedValue?: boolean) => void;
-export declare type LookupFunction<T, K extends keyof T = keyof T> = (n: K) => DeepReadonly<T[K]> | undefined;
+/**
+ * Options accepted by the register* functions.
+ */
+export interface RegisterOptions {
+    /**
+     * If true and the value is a provider function it is only invoked once,
+     * otherwise the function is invoked for every call for key.
+     * Default is true.
+     */
+    cacheProvidedValue?: boolean;
+    /**
+     * If true and and there is an already existing provider, then the existing provider is replaced.
+     * Otherwise an error is thrown.
+     */
+    overwrite?: boolean;
+}
+/**
+ * A value interceptor.
+ */
+export interface Interceptor {
+    /**
+     * The interceptor is informed about any config key access.
+     * The lookupValue function can be used to fetch the original configuration value.
+     * Or the interceptor may return custom values.
+     *
+     * @param key config key
+     * @param lookupValue a function providing the original config value
+     */
+    (key: string, lookupValue: () => SupportedValueTypes): SupportedValueTypes | undefined;
+}
+/**
+ * This class implements the internal lazy configuration state.
+ * It is exported for test purpose only.
+ *
+ * @internal
+ */
 export declare class LazyValues<SupportedKeys, Key extends keyof SupportedKeys = keyof SupportedKeys> {
     #private;
+    interceptor: Interceptor | undefined;
     get<K extends Key>(k: K): DeepReadonly<SupportedKeys[K]> | undefined;
     registeredKeys(): Set<Key>;
-    register<K extends Key>(key: K, valueProvider: ValueOrProvider<SupportedKeys, K>, cacheProvidedValue?: boolean): void;
+    register<K extends Key>(key: K, valueProvider: ValueOrProvider<SupportedKeys, K>, { cacheProvidedValue, overwrite }?: RegisterOptions): void;
+    isRegistered(key: Key): boolean;
+    unregister(key: Key): boolean;
 }
 /**
  * Returns the configuration value associated with the given key.
  * Returns undefined if the key is not known.
  */
 export declare function configValue<K extends ConfigKey>(k: K): DeepReadonly<WellknownConfigKeys[K]> | undefined;
-/**
- * Returns the environment value associated with the given key.
- * Returns undefined if the key is not known.
- */
-export declare function envValue<K extends EnvKey>(k: K): DeepReadonly<WellknownEnvKeys[K]> | undefined;
 /**
  * Registers a new key with the configuration.
  * Keys and values must also be declared at the type level by extending the `WellknownConfigKeys` interface.
@@ -249,10 +288,28 @@ export declare function envValue<K extends EnvKey>(k: K): DeepReadonly<Wellknown
  *
  * @param key the configuration key
  * @param value the value or a function returning the value (for lazy evaluation).
- * @param cacheProvidedValue if true and the value is a function it is only invoked once,
- *                  otherwise the function is invoked for every call for key.
+ * @param options registration flags
+ */
+export declare function registerConfigValue<K extends keyof WellknownConfigKeys>(key: K, valueOrProvider: ValueOrProvider<WellknownConfigKeys, K>, options?: RegisterOptions): void;
+/**
+ * The intention of this function is to make testing simpler.
+ * A test can register a config value and unregister it afterwards.
+ * @param key a config key
+ * @returns true if conf value was un-registered(previously registered)
+ */
+export declare function unregisterConfigValue<K extends keyof WellknownConfigKeys>(key: K): boolean;
+/**
+ * The intention of this function is to make testing simpler.
+ *
+ * Do not forget to unset your interceptor after the tests.
+ * @param interceptor a callback informed about any config value access.
  */
-export declare const registerConfigValue: RegisterFunction<WellknownConfigKeys>;
+export declare function setConfigValueInterceptor(interceptor?: Interceptor): void;
+/**
+ * Returns the environment value associated with the given key.
+ * Returns undefined if the key is not known.
+ */
+export declare function envValue<K extends EnvKey>(k: K): DeepReadonly<WellknownEnvKeys[K]> | undefined;
 /**
  * Registers a new environment key with the configuration.
  * Keys and values must also be declared at the type level by extending the `WellknownEnvKeys` interface.
@@ -261,8 +318,21 @@ export declare const registerConfigValue: RegisterFunction<WellknownConfigKeys>;
  *
  * @param key the env key
  * @param value the value or a function returning the value (for lazy evaluation).
- * @param cacheProvidedValue if true and the value is a function it is only invoked once,
- *                  otherwise the function is invoked for every call for key.
+ * @param options registration flags
+ */
+export declare function registerEnvValue<K extends keyof WellknownEnvKeys>(key: K, valueOrProvider: ValueOrProvider<WellknownEnvKeys, K>, options?: RegisterOptions): void;
+/**
+ * The intention of this function is to make testing simpler.
+ * A test can register a env value and unregister it afterwards.
+ * @param key a env key
+ * @returns true if env value was un-registered(previously registered)
+ */
+export declare function unregisterEnvValue<K extends keyof WellknownEnvKeys>(key: K): boolean;
+/**
+ * The intention of this function is to make testing simpler.
+ *
+ * Do not forget to unset the interceptor after the tests.
+ * @param interceptor a callback informed about any env value access.
  */
-export declare const registerEnvValue: RegisterFunction<WellknownEnvKeys>;
+export declare function setEnvValueInterceptor(interceptor?: Interceptor): void;
 export {};

package/apprt-esri-init/CredentialStorage.d.ts

@@ -4,5 +4,5 @@ export default function _default(identityManager: any, opts: any): {
     get: () => any;
     clear: () => void;
     watchForChanges: () => void;
-    isWatchingForChanges: () => boolean;
+    isWatchingForChanges(): boolean;
 };

package/package.json

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

package/selection-resultcenter/CachingStore.d.ts

@@ -17,16 +17,15 @@ export default class CachingStore {
     getMetadata(object: any): any;
     getIdentity(object: any): any;
     _getAllMasterStoreFields(): import("../../apprt/apprt-core/Promise").ExtendedPromise<{}>;
-    _getItems(itemIds: any, opts: any): any;
-    _fixCount(opts: any, itemIds: any): any;
+    _getItems(itemIds: any, opts: any): Promise<any[]>;
     _buildQuery(itemIds: any): {};
     _isGeometryRequired(options: any, defaultRequired: any): Any;
     _getGeometryFromCache(id: any, offset: any): any;
     _isSpatialQuery(query: any): boolean;
-    _getItemsFromCache(query: any, options?: {}): import("../store-api/api/Store").ResultItems<Readonly<Record<string, any>>>;
+    _getItemsFromCache(query: any, options?: {}): import("store-api/api/Store").ResultItems<Readonly<Record<string, any>>>;
     _getGeometryForItems(items: any, options: any): import("../../apprt/apprt-core/Promise").ExtendedPromise<any>;
     _getItemsForQuery(query: any, options: any): import("../../apprt/apprt-core/Promise").ExtendedPromise<any[]>;
-    query(query: any, options: any): import("../store-api/api/Store").ResultItems<any>;
+    query(query: any, options: any): import("store-api/api/Store").ResultItems<any>;
     _synchronizedQueryOnCache(query: any, opts: any): any;
     querySequence: any;
     _queryOnCache(query: any, opts: any): import("../../apprt/apprt-core/Promise").ExtendedPromise<any>;

package/store-api/api/Store.d.ts

@@ -9,6 +9,11 @@ export declare type IndexableThing = Readonly<Record<string, any>>;
 export interface ResultItems<ItemType extends IndexableThing> extends ReadonlyArray<ItemType> {
     /** Total number of available items in the result. */
     readonly total?: number;
+    /**
+     * Set to true if by the store to indicate that there are more results.
+     * The client may query again with an appropriate `start` value.
+     */
+    readonly hasMore?: boolean;
     /** Function to cancel the query. It is always 'undefined' in synchronous responses. */
     readonly cancel?: undefined;
     /** Function to react on the provided result. It is always 'undefined' in synchronous responses. */