@conterra/ct-mapapps-typings 4.13.1 → 4.13.2-PRE-1

package/apprt-dom/geometry.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Represents the size of an HTML node, including its margin.
+ */
+export interface MarginSize {
+    /** The width of the node (in pixels). */
+    w: number;
+    /** The height of the node (in pixels). */
+    h: number;
+}
+/**
+ * MarginBox defines the outer size and top-left position of a domNode.
+ * Outer size is the element's size including it's margin.
+ */
+export interface MarginBox extends MarginSize {
+    /** The horizontal position (leftmost) of this node (in pixels). */
+    l: number;
+    /** The vertical position (topmost) of this node (in pixels). */
+    t: number;
+}
+/**
+ * Retrieves the MarginBox for a given node.
+ *
+ * @param node a dom node
+ */
+export declare function getMarginBox(node: HTMLElement): MarginBox;
+/**
+ * Retrieves the MarginSize for a given node.
+ *
+ * @param node a dom node
+ */
+export declare function getMarginSize(node: HTMLElement): MarginSize;
+/**
+ * Sets the MarginBox for a given node.
+ *
+ * @param node a dom node
+ * @param marginBox
+ *      Position and dimension for the MarginBox (left, top, width and height).
+ *      All properties are optional.
+ */
+export declare function setMarginBox(node: HTMLElement, marginBox: Partial<MarginBox>): void;

package/apprt-dom/index.d.ts

@@ -1,2 +1,3 @@
-export * from "./elements";
 export * from "./css";
+export * from "./elements";
+export * from "./geometry";

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/apprt-esri-init/IdentityRequestInterceptor.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="arcgis-js-api" />
+import { AfterInterceptorData, apprtFetch, BeforeInterceptorData, Interceptor } from "apprt-fetch";
+declare type IdentityManager = __esri.IdentityManager;
+export declare class IdentityRequestInterceptor implements Interceptor {
+    #private;
+    constructor(identityManager: IdentityManager, fetch?: typeof apprtFetch);
+    before({ target, context }: BeforeInterceptorData): void;
+    after(data: AfterInterceptorData): Promise<void | Response>;
+    private doIntercept;
+}
+export {};

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

@@ -1,4 +1,4 @@
-export default function _default(identityManager: any): {
-    register: () => void;
-    unregister: () => void;
+export default function Registration(identityManager: any): {
+    register(): void;
+    unregister(): void;
 };

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

@@ -0,0 +1,18 @@
+/// <reference types="arcgis-js-api" />
+declare type IdentityManager = __esri.IdentityManager;
+declare type Credential = __esri.Credential;
+export declare const SERVER_IDENT_FAILED = "identity-manager:server-identification-failed";
+export declare const SERVER_UNKNOWN_RESOURCE = "identity-manager:unknown-resource";
+/**
+ * Performs credential lookup on the given identity manager with apprt extensions.
+ */
+export declare function findCredential(identityManager: IdentityManager, url: string): Credential | undefined;
+/**
+ * Returns true if the json response from the server indicates an authentication problem.
+ */
+export declare function isIdentityManagerError(jsonResponse: any): boolean;
+/**
+ * Returns true if the given http status code indicates an authentication problem.
+ */
+export declare function isIdentityManagerStatus(httpStatus: number): boolean;
+export {};

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

@@ -1,2 +1 @@
-export default initEsriConfig;
-declare function initEsriConfig(opts: any): void;
+export default function initEsriConfig(opts: any): void;

package/apprt-fetch/ContentType.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Exports some default content types as optional utilities.
+ *
+ * @example use JSON content type in request headers
+ * ```js
+ *    import { apprtFetch, ContentType } from "apprt-fetch";
+ *
+ *    apprtFetch(url, {
+ *          method: "POST",
+ *          headers: {
+ *              "Content-Type": ContentType.JSON_UTF8
+ *              "Accept": ContentType.JSON
+ *          }
+ *     });
+ * ```
+ */
+export declare enum ContentType {
+    /**
+     * Content-Type: text/plain
+     */
+    TEXT_PLAIN = "text/plain",
+    /**
+     * Content-Type: text/plain;charset=UTF-8
+     */
+    TEXT_PLAIN_UTF8 = "text/plain;charset=UTF-8",
+    /**
+     * Content-Type: application/json
+     */
+    JSON = "application/json",
+    /**
+     * Content-Type: application/json;charset=UTF-8
+     */
+    JSON_UTF8 = "application/json;charset=UTF-8",
+    /**
+     * Content-Type: application/xml
+     */
+    XML = "application/xml",
+    /**
+     * Content-Type: application/xml;charset=UTF-8
+     */
+    XML_UTF8 = "application/xml;charset=UTF-8",
+    /**
+     * Content-Type: text/xml
+     */
+    TEXT_XML = "text/xml",
+    /**
+     * Content-Type: text/xml;charset=UTF-8
+     */
+    TEXT_XML_UTF8 = "text/xml;charset=UTF-8",
+    /**
+     * Content-Type: application/x-www-form-urlencoded
+     */
+    FORM_URLENCODED = "application/x-www-form-urlencoded",
+    /**
+     * Content-Type: application/x-www-form-urlencoded;charset=UTF-8
+     */
+    FORM_URLENCODED_UTF8 = "application/x-www-form-urlencoded;charset=UTF-8"
+}

package/apprt-fetch/TimeoutController.d.ts

@@ -0,0 +1,16 @@
+export declare type TimeoutControllerState = "pending" | "aborted" | "timeout" | "destroyed";
+export declare class TimeoutController {
+    private controller;
+    private timeoutMillis;
+    private originalSignal;
+    private originalAbortHandle;
+    private timeoutId;
+    private internalState;
+    readonly signal: AbortSignal;
+    static create(timeoutMs: number, originalSignal: AbortSignal | undefined): TimeoutController;
+    private constructor();
+    private init;
+    destroy(): void;
+    get state(): TimeoutControllerState;
+    private stopListening;
+}

package/apprt-fetch/config.d.ts

@@ -0,0 +1,30 @@
+import { DeepReadonly } from "apprt-core/Types";
+import type { Config, Interceptor, ProxyRule, TrustedServer } from ".";
+import { OriginPattern } from "./origin";
+export declare class FetchConfig implements Config {
+    defaultProxy: string | undefined;
+    disableProxySupport: boolean;
+    maxUrlLength: number;
+    timeoutMillis: number;
+    readonly _internalProxyRules: InternalProxyRule[];
+    readonly _internalTrustedServers: InternalTrustedServer[];
+    readonly _internalInterceptors: Interceptor[];
+    get proxyRules(): DeepReadonly<ProxyRule>[];
+    get trustedServers(): DeepReadonly<TrustedServer>[];
+    get interceptors(): DeepReadonly<Interceptor>[];
+    addProxyRule(rule: ProxyRule): void;
+    removeProxyRule(rule: Pick<ProxyRule, "origin">): void;
+    addTrustedServer(server: TrustedServer): void;
+    removeTrustedServer(server: Pick<TrustedServer, "origin">): void;
+    registerInterceptor(interceptor: Interceptor): {
+        remove(): void;
+    };
+}
+export interface InternalProxyRule {
+    origin: OriginPattern;
+    proxyUrl?: string;
+}
+export interface InternalTrustedServer {
+    origin: OriginPattern;
+}
+export declare function applyGlobalConfig<T extends Config>(config: T): T;

package/apprt-fetch/fetch.d.ts

@@ -0,0 +1,58 @@
+import { ApprtRequestTarget, ApprtRequestInit, ProxyUrlOptions } from "./index";
+import { FetchConfig } from "./config";
+export declare type FetchFunction = (request: Request) => Promise<Response>;
+export declare class ApprtFetchImpl {
+    #private;
+    get config(): FetchConfig;
+    private readonly rawFetch;
+    constructor(rawFetch: FetchFunction);
+    destroy(): void;
+    /**
+     * Performs a request using the provided arguments and returns the response wrapped into a promise.
+     * This is the similar to the browser API's `fetch(...)` call.
+     */
+    fetch(initialTarget: ApprtRequestTarget, init?: ApprtRequestInit): Promise<Response>;
+    fetchJson<T = unknown>(target: ApprtRequestTarget, init?: ApprtRequestInit): Promise<T>;
+    getProxiedUrl(target: ApprtRequestTarget): URL;
+    getProxiedUrl(target: ApprtRequestTarget, options?: ProxyUrlOptions & {
+        check?: false;
+    }): URL;
+    getProxiedUrl(target: ApprtRequestTarget, options?: ProxyUrlOptions): URL | undefined;
+    /**
+     * Invokes all 'before' interceptors.
+     * Returns the target URL since interceptors are allowed to modify it.
+     *
+     * NOTE: interceptors are allowed to mutate the contents of `options` and `context`.
+     * All other attributes are read only.
+     */
+    private invokeBeforeInterceptors;
+    /**
+     * Invokes all 'after' interceptors.
+     * Returns the Response since after interceptors are allowed to override it.
+     *
+     * NOTE: interceptors are allowed to mutate the contents of `context`.
+     * All other attributes are read only.
+     */
+    private invokeAfterInterceptors;
+    /**
+     * Performs the actual request logic, including builtin features like proxy support and trusted servers.
+     */
+    private doFetch;
+    private repeatableFetch;
+    /**
+     * Applies the proxy settings to the given target URL.
+     * Checks whether a proxy server is required for the given host or if usage is forced on/off.
+     * Returns the updated target URL and a flag to indicate whether a proxy rule was applied.
+     */
+    private buildProxyUrl;
+    /**
+     * Returns true if there is a trusted server rule that matches the given target URL.
+     * Trusted servers may receive credentials by default.
+     */
+    private isTrusted;
+    /**
+     * Searches for a proxy rule that matches the given target URL and returns the matching proxy server URL.
+     * Returns undefined if there is no matching proxy server.
+     */
+    private findProxyServer;
+}