@conterra/ct-mapapps-typings 4.13.0-next.20220121045321 → 4.13.0-next.20220128050323

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

@@ -0,0 +1,6 @@
+export class TokenRequestInterceptor {
+    before(params: any): Promise<void>;
+    activate(): void;
+    deactivate(): void;
+    #private;
+}

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

@@ -1 +1,2 @@
 export { default as Activator } from "./Activator";
+export { TokenRequestInterceptor } from "./TokenRequestInterceptor";

package/apprt-request/_request.d.ts

@@ -1,35 +1,7 @@
-export default request;
+import "dojo/request";
+import { ConfigurableRequestFunction } from "./api";
 /**
  * Execute http request.
- * @param {string} url
- * @param {Record<string,any>} options
- * @returns {Promise<any>}
  */
-declare function request(url: string, options: Record<string, any>): Promise<any>;
-declare namespace request {
-    export function registered(): boolean;
-    export function register(): void;
-    export { unregister };
-    export { conf as config };
-    export const getProxiedUrl: (url: any, opts: any) => any;
-}
-declare function unregister(): void;
-declare const conf: {
-    buildProvider: () => {
-        (url: any, options: any): any;
-        getProxiedUrl(url: any, opts: any): any;
-    };
-    set: (name: any, value: any) => void;
-    get: (name: any) => any;
-    addProxyRule: (rule: any) => void;
-    removeProxyRule: (proxyRule: any) => void;
-    addTrustedServer: (trustedServer: any) => void;
-    addCorsEnabledServer: (corsServer: any) => void;
-    removeTrustedServer: (trustedServer: any) => void;
-    removeCorsEnabledServer: (corsServer: any) => void;
-    addPreProcessor: (preProcessor: any) => void;
-    removePreProcessor: (preProcessor: any) => void;
-    addPostProcessor: (postProcessor: any) => void;
-    removePostProcessor: (postProcessor: any) => void;
-    reset: () => void;
-};
+export declare const request: ConfigurableRequestFunction;
+export default request;

package/apprt-request/api.d.ts

@@ -0,0 +1,329 @@
+/**
+ * Format of a proxy rule config option.
+ */
+export interface ProxyRuleDescriptor {
+    origin: string;
+    proxyUrl?: string | undefined;
+}
+/**
+ * Format of a trusted server config option.
+ */
+export interface TrustedServerDescriptor {
+    origin: string;
+}
+/**
+ * Format of a CORS server config option.
+ * Cors is enabled by default.
+ * @deprecated
+ */
+export interface CorsServerDescriptor extends TrustedServerDescriptor {
+    withCredentials?: boolean;
+}
+/**
+ * Pre/Post-Processor parameters.
+ */
+export interface ProcessorParams {
+    /**
+     * Processors may add flags to the parameters to communicate state changes.
+     */
+    [additionalKey: string]: any;
+    /**
+     * Flag which indicates that the url was wrapped into a proxy url.
+     */
+    proxyAppended?: boolean;
+    /**
+     * URL to request.
+     */
+    url: string;
+    /**
+     * Request options.
+     */
+    options: ProcessorRequestOptions;
+}
+/**
+ * A request pre-processor function.
+ */
+export interface PreProcessor {
+    /**
+     * @param params input parameter, allowed to be changed.
+     * @returns If a value is returned and the processor is not async then the value is the response.
+     * If a Promise is returned and the processor is async, then the processing will wait until the promise resolves.
+     * If the promise resolves not to undefined then this is interpreted as the response.
+     * If the result is interpreted as response it will be wrapped in a promise.
+     */
+    (params: ProcessorParams): Promise<any> | any;
+    /**
+     * Indicates that this processors behaves async.
+     */
+    async?: boolean;
+}
+/**
+ * A request post-processor function.
+ */
+export interface PostProcessor {
+    /**
+     * @param result the request response manipulated maybe by other processors.
+     * @param params the request input parameter.
+     * @returns manipulated response. If it is not a promise, it will be wrapped, into one.
+     */
+    (result: Promise<any>, params: ProcessorParams): Promise<any> | any;
+}
+/**
+ * All config options.
+ */
+export interface ConfigProperties {
+    /**
+     * Maximal length of a url before a GET request is switched to POST.
+     */
+    maxUrlLength: number;
+    /**
+     * Request timeout in msec.
+     */
+    timeout: number;
+    /**
+     * Default proxy url.
+     */
+    proxyUrl: string;
+    /**
+     * Proxy use rules.
+     */
+    proxyRules: ProxyRuleDescriptor[];
+    /**
+     * Globally disable the proxy support.
+     */
+    disableProxySupport: boolean;
+    /**
+     * Trusted servers, for which 'withCredentials' will be enabled.
+     */
+    trustedServers: TrustedServerDescriptor[];
+    /**
+     * Custom pre-processors.
+     */
+    customPreProcessors: PreProcessor[];
+    /**
+     * Custom post-processors.
+     */
+    customPostProcessors: PostProcessor[];
+    /**
+     * Flag to enable/disable to return dojo deferred instead of a Promise.
+     */
+    returnDojoDeferred: boolean;
+}
+/**
+ * Config property key.
+ */
+export declare type ConfigPropertyKey = keyof ConfigProperties;
+export interface ExtendedDojoProvider extends RequestFunction {
+    getProxiedUrl(url: string, opts?: {
+        force?: boolean;
+    }): string;
+}
+/**
+ * Configuration interface.
+ */
+export interface Config {
+    /**
+     * Only for internal usage.
+     */
+    buildProvider(): ExtendedDojoProvider;
+    /**
+     * Set a config option.
+     * @param name name of the option.
+     * @param value value of the option.
+     */
+    set<Name extends ConfigPropertyKey>(name: Name, value: ConfigProperties[Name]): void;
+    set(name: string, value: unknown): void;
+    /**
+     * Get a config option.
+     * @param name name of the option.
+     */
+    get<Name extends ConfigPropertyKey>(name: Name): ConfigProperties[Name];
+    get(name: string): unknown;
+    /**
+     * Register a proxy rule. If the rule matches, the request will be routed over a proxy.
+     * @param rule a proxy rule.
+     */
+    addProxyRule(rule: ProxyRuleDescriptor): void;
+    /**
+     * Removes a proxy rule.
+     * @param rule the rule to remove.
+     */
+    removeProxyRule(rule: ProxyRuleDescriptor): void;
+    /**
+     * Register a trusted server, for which 'withCredentials' will be activated.
+     * @param server a trusted server.
+     */
+    addTrustedServer(server: TrustedServerDescriptor): void;
+    /**
+     * Removes a trusted servers.
+     * @param server a trusted server.
+     */
+    removeTrustedServer(server: TrustedServerDescriptor): void;
+    /** @deprecated */
+    addCorsEnabledServer(server: CorsServerDescriptor): void;
+    /** @deprecated */
+    removeCorsEnabledServer(server: CorsServerDescriptor): void;
+    /**
+     * Register a pre-processor
+     * @param processor a pre-processor
+     */
+    addPreProcessor(processor: PreProcessor): void;
+    /**
+     * Unregister a pre-processor
+     * @param processor a pre-processor
+     */
+    removePreProcessor(processor: PreProcessor): void;
+    /**
+     * Register a post-processor
+     * @param processor a post-processor
+     */
+    addPostProcessor(processor: PostProcessor): void;
+    /**
+     * Unregister a post-processor
+     * @param processor a post-processor
+     */
+    removePostProcessor(processor: PostProcessor): void;
+    /**
+     * Reset the configuration to it's defaults.
+     * Only intended for tests.
+     */
+    reset(): void;
+}
+/**
+ * Request options
+ */
+export interface RequestOptions {
+    /**
+     * Processors may allow additional properties
+     */
+    [key: string]: any;
+    /**
+     * HTTP METHOD
+     * If not specified GET is used.
+     */
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD";
+    /**
+        Request timeout in msec.
+     */
+    timeout?: number;
+    /**
+     *  AbortSignal to cancel the request.
+     */
+    signal?: AbortSignal;
+    /**
+     * HTTP Headers.
+     */
+    headers?: Record<string, any>;
+    /**
+     * Query Parameter.
+     * Note, if data is not defined and method is post this will be converted to the post body.
+     */
+    query?: Record<string, any>;
+    /**
+     *  Request body (used if POST/PUT)
+     */
+    data?: Record<string, any> | string;
+    /**
+     * How to interpret the response. Default is "json".
+     */
+    handleAs?: "json" | "javascript" | "text" | "xml" | "blob" | "binary";
+    /**
+     * Option to mark target url as 'cors' trusted.
+     * Please prefer to register a trusted servers via config.
+     */
+    useCors?: {
+        withCredentials?: boolean;
+    };
+    /**
+     * Option to mark request to include credentials.
+     * Please prefer to register a trusted servers via config.
+     * @deprecated
+     */
+    withCredentials?: boolean;
+    /**
+     * Allows per request configuration of maximal url length. If it is to long a GET request will be switched to POST.
+     * Please prefer the config option 'maxUrlLength'.
+     */
+    maxUrlLength?: number;
+    /**
+     * Flag will create random 'salt' to the query parameters to prevent browser caching.
+     */
+    preventCache?: boolean;
+    /**
+     * Enables jsonp request processing (response is interpreted as javascript).
+     * If true it appends query parameter 'callback=<methodname>'.
+     * If it is a string then `<jsonp value>=<methodname>` will be appended.
+     * Please use CORS, this will not be supported in future versions.
+     * @deprecated
+     */
+    jsonp?: boolean | string;
+    /**
+     * Allows 'static' jsonp.
+     * If jsonp is true and jsonpfn is configured the the
+     * query parameter 'callback=<jsonpfn value>' is appended.
+     * The javascript method name is controlled by the caller and not dynamically created.
+     * @deprecated
+     */
+    jsonpfn?: string;
+    /**
+     * Enables/disables the use of a proxy.
+     * True is the default value and a proxy is used if the CORS communication, fails.
+     * False prevents the use of a proxy.
+     * "force" skips the CORS detection and enforces the use of a proxy.
+     * Please prefer the config option 'proxyRules' for that.
+     */
+    useProxy?: boolean | "force";
+    /**
+     * Custom pre-processors only valid for the current request.
+     * Helpful in tests.
+     * Please prefer the config option to register processors for all requests.
+     */
+    preprocessors?: PreProcessor[];
+    /**
+     * Custom post-processors only valid for the current request.
+     * Helpful in tests.
+     * Please prefer the config option to register processors for all requests.
+     */
+    postprocessors?: PostProcessor[];
+}
+/**
+ * Request options available in the processors.
+ */
+export declare type ProcessorRequestOptions = RequestOptions;
+/**
+ * A function executing a request function.
+ */
+export declare type RequestFunction = (url: string, options?: RequestOptions | undefined) => Promise<any>;
+/**
+ * The main interface of 'apprt-request'.
+ */
+export interface ConfigurableRequestFunction extends RequestFunction {
+    /**
+     * Provides access to configuration.
+     */
+    readonly config: Config;
+    /**
+     * Executes a GET request (sets method=GET in the options)
+     */
+    readonly get: RequestFunction;
+    /**
+     * Executes a POST request (sets method=POST in the options)
+     */
+    readonly post: RequestFunction;
+    /**
+     * Executes a PUT request (sets method=PUT in the options)
+     */
+    readonly put: RequestFunction;
+    /**
+     * Executes a DELETE request (sets method=DELETE in the options)
+     */
+    readonly del: RequestFunction;
+    /**
+     * Utility to create a 'proxied' url.
+     * By default it returns the input url, if no proxy rule applies.
+     * If the flag 'force' is enabled it will wrap the url with the default proxy.
+     */
+    readonly getProxiedUrl: (url: string, options?: {
+        force?: boolean;
+    }) => string;
+}

package/apprt-request/config.d.ts

@@ -1,19 +1,2 @@
-export default function _default(): {
-    buildProvider: () => {
-        (url: any, options: any): any;
-        getProxiedUrl(url: any, opts: any): any;
-    };
-    set: (name: any, value: any) => void;
-    get: (name: any) => any;
-    addProxyRule: (rule: any) => void;
-    removeProxyRule: (proxyRule: any) => void;
-    addTrustedServer: (trustedServer: any) => void;
-    addCorsEnabledServer: (corsServer: any) => void;
-    removeTrustedServer: (trustedServer: any) => void;
-    removeCorsEnabledServer: (corsServer: any) => void;
-    addPreProcessor: (preProcessor: any) => void;
-    removePreProcessor: (preProcessor: any) => void;
-    addPostProcessor: (postProcessor: any) => void;
-    removePostProcessor: (postProcessor: any) => void;
-    reset: () => void;
-};
+import type { Config } from "./api";
+export default function createConfig(): Config;

package/apprt-request/dconfig.d.ts

@@ -1,2 +1,2 @@
-export function configure(configRoot: any): void;
-export function load(id: any, require: any, callback: any): void;
+export declare function configure(configRoot?: any): void;
+export declare function load(this: any, id: string, require: any, callback: (value: any) => void): void;

package/apprt-request/impl/PostProcessor-corsProxyFallback.d.ts

@@ -1 +1,2 @@
-export default function PostProcessorCorsProxyFallback(proxyUrl: any, proxyRules: any): (result: any, params: any) => any;
+import { ProxyRuleDescriptor, PostProcessor } from "../api";
+export default function PostProcessorCorsProxyFallback(proxyUrl: string, proxyRules: ProxyRuleDescriptor[]): PostProcessor;

package/apprt-request/impl/PrePostProcessorEngine.d.ts

@@ -1 +1,12 @@
-export default function PrePostProcessorEngine(engineConfig: any): (url: any, options: any) => any;
+import { RequestOptions, PreProcessor, PostProcessor } from "../api";
+export interface EngineConfig {
+    providerSelector: any;
+    preProcessors: PreProcessor[];
+    postProcessors: PostProcessor[];
+}
+export declare type RequestEngineOptions = RequestOptions & {
+    skipAsyncPreProcessors?: boolean;
+    executePostProcessors?: boolean;
+};
+export declare type PrePostProcessorEngine = (url: string, options: RequestEngineOptions) => any;
+export declare function PrePostProcessorEngineFactory(engineConfig: EngineConfig): PrePostProcessorEngine;

package/apprt-request/impl/PreProcessor-defaults.d.ts

@@ -1 +1,2 @@
-export default function PreProcessorDefaults(defaults: any): (params: any) => void;
+import { PreProcessor, RequestOptions } from "../api";
+export default function PreProcessorDefaults(defaults: Pick<RequestOptions, "method" | "timeout">): PreProcessor;

package/apprt-request/impl/PreProcessor-handleAs.d.ts

@@ -1 +1,2 @@
-export default function PreProcessorHandleAs(mappings: any): (params: any) => void;
+import { PreProcessor } from "../api";
+export default function PreProcessorHandleAs(): PreProcessor;

package/apprt-request/impl/PreProcessor-maxUrlLength.d.ts

@@ -1 +1,2 @@
-export default function PreProcessorMaxUrlLength(postLength: any): (params: any) => void;
+import { PreProcessor } from "../api";
+export default function PreProcessorMaxUrlLength(postLength: number): PreProcessor;

package/apprt-request/impl/PreProcessor-proxy.d.ts

@@ -1 +1,3 @@
-export default function PreProcessorProxy(proxyRules: any, defaultProxyUrl: any): (params: any) => void;
+import { PreProcessor } from "../api";
+import { ProxyRule } from "./ProxyRule";
+export default function PreProcessorProxy(proxyRules: ProxyRule[], defaultProxyUrl: string): PreProcessor;

package/apprt-request/impl/PreProcessor-secureProtocolRewrite.d.ts

@@ -1 +1,3 @@
-export default function PreProcessorSecureProtocolRewrite(proxyUrl: any, origin?: any): (params: any) => void;
+import { Origin } from "./origin";
+import { PreProcessor } from "../api";
+export default function PreProcessorSecureProtocolRewrite(proxyUrl: string, origin?: Origin): PreProcessor;

package/apprt-request/impl/PreProcessor-trusted.d.ts

@@ -1 +1,2 @@
-export default function PreProcessorTrusted(trustedServers: any): (params: any) => void;
+import { TrustedServerDescriptor, PreProcessor } from "../api";
+export default function PreProcessorTrusted(trustedServers: TrustedServerDescriptor[]): PreProcessor;

package/apprt-request/impl/ProviderSelector.d.ts

@@ -1,2 +1,3 @@
-export default function _default(url: any, options: any): Promise<any>;
-import Promise from "apprt-core/CancelablePromise";
+import { CancelablePromise } from "apprt-core/CancelablePromise";
+import { RequestOptions } from "../api";
+export default function providerSelector(url: string, options: RequestOptions): CancelablePromise<any>;

package/apprt-request/impl/ProxyRule.d.ts

@@ -1,5 +1,10 @@
-export default function ProxyRule(options: any): {
-    match(url: any): boolean;
-    apply(url: any): any;
-};
-export function applyProxyUrl(proxyUrl: any, url: any): any;
+export interface ProxyRule {
+    match(url: string): boolean;
+    apply(url: string): string;
+}
+export declare function ProxyRule(options: {
+    origin: string;
+    proxyUrl: string;
+}): ProxyRule;
+export default ProxyRule;
+export declare function applyProxyUrl(proxyUrl: string, url: string): string;

package/apprt-request/impl/origin.d.ts

@@ -1,2 +1,16 @@
-export default master;
-declare let master: any;
+export interface OriginUtil {
+    readonly $origin: Origin;
+    isFileLocation(): boolean;
+    isCrossDomainUrl(url: string | Origin): boolean;
+    isMatchingOrigin(origin: string | Origin, url: string | Origin): boolean;
+}
+export interface Origin {
+    protocol: string;
+    hostname: string;
+    port: string;
+    path: string;
+    equals(other: Origin): boolean;
+}
+declare const _default: OriginUtil;
+export default _default;
+export declare function createOriginUtil(originStr: string, injectWildcards?: boolean): OriginUtil;

package/apprt-request/main.d.ts

@@ -1,2 +1,2 @@
-export default req;
 import req from "./_request";
+export default req;

package/apprt-tokens/TokenRequestPreProcessor.d.ts

@@ -0,0 +1,9 @@
+import type { TokenService } from "apprt-tokens/api";
+import type { ProcessorParams } from "apprt-request/api";
+export declare class TokenRequestPreProcessor {
+    #private;
+    set tokenService(srv: TokenService);
+    preprocess(params: ProcessorParams): Promise<void> | undefined;
+    activate(): void;
+    deactivate(): void;
+}

package/apprt-tokens/TokenServiceImpl.d.ts

@@ -0,0 +1,21 @@
+import type { Token, TokenService } from "./api";
+import type { UserAdminService } from "system/module";
+interface ConfigProperties {
+    secMode: string;
+    tokenServiceUrl: string;
+}
+interface TokenState {
+    error?: Error | undefined;
+    token?: InternalToken;
+}
+interface InternalToken extends Token {
+    issuer?: string;
+}
+export declare class TokenServiceImpl implements TokenService {
+    #private;
+    set userAdmin(value: UserAdminService);
+    set _properties(value: ConfigProperties);
+    findTokenFor(target: string): Promise<Token | undefined>;
+    fetchTokenInfo(target: string): Promise<TokenState>;
+}
+export {};

package/apprt-tokens/api.d.ts

@@ -0,0 +1,7 @@
+export interface Token {
+    readonly value: string;
+    readonly expires?: Date;
+}
+export interface TokenService {
+    findTokenFor(target: string): Promise<Token | undefined>;
+}

package/apprt-tokens/module.d.ts

@@ -0,0 +1,2 @@
+export { TokenServiceImpl as TokenService } from "./TokenServiceImpl";
+export { TokenRequestPreProcessor } from "./TokenRequestPreProcessor";

package/coordinatetransformer/ProjectionEngineTransformerStrategy.d.ts

@@ -1,4 +1,3 @@
-export { isSupportedWebAssembly as isSupported };
 export default class ProjectionEngineTransformerStrategy {
     init(opts: any): Promise<void>;
     transform: ((geometry: any, sourceSRS: any, targetSRS: any) => Promise<__esri.Geometry | __esri.Geometry[]>) | ((geometry: any, sourceSRS: any, targetSRS: any) => __esri.Geometry | __esri.Geometry[]) | undefined;
@@ -6,4 +5,4 @@ export default class ProjectionEngineTransformerStrategy {
     _transformAsync(geometry: any, sourceSRS: any, targetSRS: any): Promise<__esri.Geometry | __esri.Geometry[]>;
     #private;
 }
-declare function isSupportedWebAssembly(): boolean;
+export function isSupported(): boolean;

package/ct/request.d.ts

@@ -3,7 +3,9 @@ declare function request(opts: any, flags: any): Promise<any>;
 declare namespace request {
     export { request };
     export function requestJSON(params: any, flags: any): Promise<any>;
-    export const getProxiedUrl: (url: any, opts: any) => any;
+    export const getProxiedUrl: (url: string, options?: {
+        force?: boolean | undefined;
+    } | undefined) => string;
     export namespace preprocessors {
         function add(p: any, first: any): void;
         function remove(p: any): void;

package/package.json

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

package/portal-item-service/PortalItemService.d.ts

@@ -18,7 +18,7 @@ declare function PortalItemService(): {
     getPortalUrlById(id: any): any;
     updateItem(portalItem: any, properties: any): any;
     updateThumbnailItem(portalItemId: any, thumbnailUrl: any): any;
-    getAppRegistrationInfo(portalItem: any): any;
-    registerOAuth(portalItemId: any, appName: any): any;
-    unregisterOAuth(clientId: any): any;
+    getAppRegistrationInfo(portalItem: any): Promise<any>;
+    registerOAuth(portalItemId: any, appName: any): Promise<any>;
+    unregisterOAuth(clientId: any): Promise<any>;
 };

package/search-api/api.d.ts

@@ -150,6 +150,10 @@ export interface SelectedEvent {
 }
 /** Describes the item source for a selection event. */
 export interface ItemSource {
+    /**
+     * The type of this source. Currently always 'store', but more types (with different properties)
+     * may be added later.
+     */
     readonly type: "store";
     /** Store instance that returned the item. */
     readonly store: Store<any>;