@conterra/ct-mapapps-typings 4.19.0-next.20241122052258 → 4.19.0-next.20241125073200

package/apprt-core/Types.d.ts

@@ -120,6 +120,10 @@ interface Watchable<WatchableProperties> {
  * ```
  */
 type ExtensibleUnion<Values extends BaseType, BaseType extends number | string> = Values | ({} & BaseType);
+/**
+ * An object that constructs instances of type T.
+ */
+type Constructor<T, Args extends unknown[] = unknown[]> = new (...args: Args) => T;
 declare const _default: null;
 
-export { type DeepReadonly, type DeepWritable, type Equal, type EventCallback, type EventEmitter, type EventSource, type ExtensibleUnion, type Handle, type Primitive, type RequiredProps, type TupleKeys, type WatchCallback, type WatchEvent, type Watchable, type Writable, _default as default };
+export { type Constructor, type DeepReadonly, type DeepWritable, type Equal, type EventCallback, type EventEmitter, type EventSource, type ExtensibleUnion, type Handle, type Primitive, type RequiredProps, type TupleKeys, type WatchCallback, type WatchEvent, type Watchable, type Writable, _default as default };

package/apprt-fetch/index.d.ts

@@ -295,11 +295,12 @@ interface Handle {
  */
 interface Config {
     /**
-     * Maximum length of an url before a GET request is switched to POST.
+     * Maximum length of an url before a GET request is switched to POST
+     * (if {@link ApprtRequestInit.supportsPostSwitching | supportsPostSwitching} is true for a request).
      * GET requests altered in this way will have their query parameters
      * placed into the new POST request's body (as content-type application/x-www-form-urlencoded).
      *
-     * Switching to POST requests can be disabled by setting this property to a value `<= 0`.
+     * Switching to POST requests can be disabled entirely by setting this property to a value `<= 0`.
      */
     maxUrlLength: number;
     /**
@@ -398,6 +399,13 @@ interface ApprtRequestInit extends RequestInit {
      * If `"force-off"` is used, no proxy server will be used, even if a proxy rule would match.
      */
     proxyMode?: ProxyMode;
+    /**
+     * If set to `true`, GET requests with very long URLs (see {@link Config.maxUrlLength})
+     * will automatically switch to POST requests.
+     *
+     * Default: `false`
+     */
+    supportsPostSwitching?: boolean;
     /**
      * Convenience option to add additional query arguments to the request.
      * The transport of the given value depends on the value of `queryTransport`.

package/package.json

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

package/store-api/rest/BaseRestStore.d.ts

@@ -1,3 +1,4 @@
+import { ApprtRequestInit, ApprtRequestTarget, CustomFetch } from 'apprt-fetch';
 import { IndexableThing, AsyncStore, Metadata, GetOptions, QueryOptions, AsyncQueryResult, ResultItems } from '../api/Store.js';
 import { ComplexQueryExpression } from '../api/ComplexQueryLang.js';
 import 'apprt-core/Events';
@@ -9,10 +10,6 @@ import 'esri/geometry/Geometry';
 interface RequestOptions {
     /** custom http headers */
     headers?: Record<string, any>;
-    /** Flag if that JSONP (javascript communication should be used), this is deprecated
-     * @deprecated
-     */
-    jsonp?: boolean;
 }
 /**
  * Extra options, provided in the hook method '_filterParams'
@@ -23,6 +20,13 @@ interface MethodParameters<ItemType, IDType> {
     object?: Partial<ItemType>;
     options: Record<string, any>;
 }
+interface InternalRequestOptions extends ApprtRequestInit {
+    url: ApprtRequestTarget;
+    data?: string;
+    query?: Record<string, any>;
+    content?: Record<string, any>;
+    headers?: Record<string, string>;
+}
 /**
  * Base Store implementation for simple rest services.
  * Provides get and query methods.
@@ -60,14 +64,6 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
      * Range parameter transporting item range definitions.
      */
     rangeParam: string;
-    /**
-     * Shall jsonp used for get and query
-     */
-    jsonp: boolean;
-    /**
-     * The jsonp request parameter
-     */
-    callbackParam: string;
     /**
      * Identifies the item array in query responses
      */
@@ -100,7 +96,7 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
      * @param options allows overwrite of any property
      * @param fetch the fetch method to use. Provided to customize in the constructor to make tests easier.
      */
-    constructor(options?: Partial<Pick<BaseRestStore<ItemType, IDType>, keyof BaseRestStore<ItemType, IDType>>>, fetch?: (url: string, options: Record<string, any>) => Promise<any>);
+    constructor(options?: Partial<Pick<BaseRestStore<ItemType, IDType>, keyof BaseRestStore<ItemType, IDType>>>, fetch?: CustomFetch);
     /**
      * Gets identity of given item.
      * @param item an item of this store.
@@ -122,18 +118,18 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
     /**
      * Queries the store for objects.
      */
-    query(query?: ComplexQueryExpression, options?: QueryOptions): AsyncQueryResult<ItemType>;
+    query(query?: ComplexQueryExpression, options?: QueryOptions & RequestOptions): AsyncQueryResult<ItemType>;
     /**
      * Hook for sub classes to add/change request parameters.
      */
-    protected _filterParams(invokedFromMethod: string, requestParameters: Record<string, any>, originalMethodParameters: MethodParameters<ItemType, IDType>): Record<string, any>;
+    protected _filterParams(invokedFromMethod: string, requestParameters: InternalRequestOptions, originalMethodParameters: MethodParameters<ItemType, IDType>): InternalRequestOptions;
     /**
      * Hook for subclasses to convert ComplexQueryExpression into request parameters.
      * @param requestParameters prepared request parameters
      * @param query the complex query
      * @param options the query options
      */
-    protected _appendQueryToRequest(requestParameters: Record<string, any>, query: ComplexQueryExpression | undefined, options: QueryOptions): void;
+    protected _appendQueryToRequest(requestParameters: InternalRequestOptions, query: ComplexQueryExpression | undefined, options: QueryOptions): void;
     /**
      * Converts the options.start and options.count values to request parameters.
      * By default the headers "Range" and "X-Range" are calculated and
@@ -142,14 +138,14 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
      * @param requestParameters request parameters will be changed
      * @param options the query options, with start + count.
      */
-    protected _appendRangeToRequest(requestParameters: Record<string, any>, options: QueryOptions): void;
+    protected _appendRangeToRequest(requestParameters: InternalRequestOptions, options: QueryOptions): void;
     /**
      * Converts the options.sort to request parameters.
      * By default the sort options are converted into 'sort' request parameter, like '-id,+name,+title'.
      * @param requestParameters request parameters to change.
      * @param options the query options.
      */
-    protected _appendSortToRequest(requestParameters: Record<string, any>, options: QueryOptions): void;
+    protected _appendSortToRequest(requestParameters: InternalRequestOptions, options: QueryOptions): void;
     /**
      * Transforms server responses into `ResultItems<T>`.
      * The default implementation expects a server response of this format:
@@ -180,9 +176,8 @@ declare class BaseRestStore<ItemType extends IndexableThing, IDType extends stri
      * @param options the request options.
      * @returns result of the request.
      */
-    protected _executeRequest<T>(method: string, options: Record<string, any>): Promise<T>;
+    protected _executeRequest<T>(method: string, options: InternalRequestOptions): Promise<T>;
     private _fetchMetadata;
-    private _checkError;
 }
 
-export { BaseRestStore, type MethodParameters, type RequestOptions };
+export { BaseRestStore, type InternalRequestOptions, type MethodParameters, type RequestOptions };

package/store-api/rest/BaseWriteableRestStore.d.ts

@@ -1,5 +1,6 @@
 import { BaseRestStore, RequestOptions } from './BaseRestStore.js';
 import { IndexableThing, AsyncWritableStore, CreateOptions } from '../api/Store.js';
+import 'apprt-fetch';
 import '../api/ComplexQueryLang.js';
 import 'esri/geometry/Geometry';
 import 'apprt-core/Events';

package/store-api/rest/RQLStore.d.ts

@@ -5,6 +5,7 @@ import { ComplexQueryOptions, ASTNode } from '../ComplexQuery.js';
 import 'apprt-core/Events';
 import 'esri/geometry/Geometry';
 import './BaseRestStore.js';
+import 'apprt-fetch';
 
 type Transformer = (node: ASTNode, queryOptions: ComplexQueryOptions, subResults?: string[]) => string;
 declare function toRQL(query?: ComplexQueryExpression, options?: ComplexQueryOptions): string;

package/store-api/rest/SQLStore.d.ts

@@ -4,6 +4,7 @@ import { BaseWriteableRestStore } from './BaseWriteableRestStore.js';
 import 'apprt-core/Events';
 import 'esri/geometry/Geometry';
 import './BaseRestStore.js';
+import 'apprt-fetch';
 
 /**
  * SQL Store is a RestStore which uses the SQL where expressions as query language.