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

package/portal-webitem-map-config/module.d.ts

@@ -1 +1,3 @@
-export {};
+export { default as DataFormBuilderWidgetFactory } from "./DataFormBuilderWidgetFactory";
+export { default as AGOLStore } from "./AGOLStore";
+export { default as WebMapFinderWidget } from "./WebMapFinderWidget";

package/portal-webscene-slides/module.d.ts

@@ -1 +1,7 @@
-export {};
+export { default as SlideSelector } from "./SlideSelector";
+export { default as SlideSelectorWidget } from "./SlideSelectorWidget";
+export { default as SlideWidget } from "./SlideWidget";
+export { default as SlideShowWidget } from "./SlideShowWidget";
+export { default as SlideModel } from "./SlideModel";
+export { default as SlideActions } from "./SlideActions";
+export { default as SlideActionStore } from "./SlideActionStore";

package/printing/module.d.ts

@@ -1 +1 @@
-export {};
+export { default as Config } from "./PrintingFactory";

package/reportmanagement/module.d.ts

@@ -1 +1,3 @@
-export {};
+export { default as ReportDetailsController } from "./ReportDetailsController";
+export { default as CreateReportController } from "./CreateReportController";
+export { default as GridColumnsExtender } from "./GridColumnsExtender";

package/reportstore/module.d.ts

@@ -1 +1 @@
-export {};
+export { default as ReportStore } from "./ReportStore";

package/reporttool/module.d.ts

@@ -1 +1,5 @@
-export {};
+export { default as ReportTask } from "./ReportTask";
+export { default as ReportToolController } from "./ReportToolController";
+export { default as ReportingToolRuleProcessor } from "./ReportingToolRuleProcessor";
+export { default as StaticReportToolController } from "./StaticReportToolController";
+export { default as ReportMappingInterpreter } from "./ReportMappingInterpreter";

package/result-api/AbstractTableModel.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="arcgis-js-api" />
+import { Evented } from "apprt-core/Events";
+import { CoordinateTransformer } from "coordinatetransformer/api";
+import type { SpatialReference } from "esri/geometry";
+import { DeepReadonly } from "vue";
+import { ItemGeometry, LoadOptions, SortSpecifier, TableField, TableItem, TableModelBase, TableModelCapabilities, TableModelEvents, TableState, TotalItemInfo } from "./api/model";
+export interface MetadataResult {
+    fields: TableField[];
+    total: TotalItemInfo;
+    supportsGeometry: boolean;
+}
+export declare type CoordinateTransformerDependency = Pick<CoordinateTransformer, "transform">;
+export interface AbstractTableModelOptions {
+    id: string;
+    title: string;
+    coordinateTransformer?: CoordinateTransformerDependency;
+}
+export declare abstract class AbstractTableModel<T extends TableItem = TableItem> extends Evented<TableModelEvents> implements TableModelBase<TableItem> {
+    #private;
+    get id(): string;
+    get capabilities(): TableModelCapabilities | undefined;
+    get title(): string;
+    get state(): TableState;
+    get fields(): DeepReadonly<TableField[]> | undefined;
+    get sortedBy(): DeepReadonly<SortSpecifier> | undefined;
+    get totalItems(): TotalItemInfo | undefined;
+    get loadError(): Error | undefined;
+    constructor(options: AbstractTableModelOptions);
+    destroy(): void;
+    load(options?: LoadOptions): Promise<void>;
+    whenLoaded(): Promise<void>;
+    setSortedBy(sortBy: SortSpecifier): void;
+    getItemsByRows(startIndex: number, count: number): Promise<T[]>;
+    getItemsById(itemIds: string[]): Promise<TableItem[]>;
+    getAllItemIds(): Promise<string[]>;
+    getGeometries(sr: SpatialReference): Promise<ItemGeometry[]>;
+    /** Called once during destruction. Override this method to execute custom cleanup code. */
+    protected destroyImpl?(): void;
+    /** Called once during load to fetch metadata. */
+    protected abstract loadMetadata(options: LoadOptions): Promise<MetadataResult>;
+    /** Called once during load (after loadMetadata()) to fetch all items. */
+    protected abstract loadItems(): Promise<T[]>;
+    /**
+     * Called when the caller requests item geometries.
+     * Must be implemented if `capabilities.supportsGeometries` is `true`.
+     * All geometries must always have the *same* srs.
+     *
+     * The returned geometries should be in the requested spatial reference system.
+     * The abstract table model may transform them using a provided coordinatetransformer if that
+     * is not the case.
+     * An error will be thrown to the caller if the SRS is not correct and no coordinate transformer was
+     * provided to the model.
+     */
+    protected loadGeometries?(sr: SpatialReference): Promise<ItemGeometry[]>;
+}

package/result-api/OpenResultsServiceImpl.d.ts

@@ -1,7 +1,7 @@
-import type { Handle, OpenResultsOptions, OpenResultsService, ResultModel } from "./api/all";
+import type { Handle, OpenResultsService, ResultModel } from "./api";
 export declare class OpenResultsServiceImpl implements OpenResultsService {
     #private;
-    private _factories;
+    private _uiFactory;
     deactivate(): void;
-    open(model: ResultModel, options?: OpenResultsOptions): Handle;
+    open(model: ResultModel): Handle;
 }

package/result-api/ResultModelFactoryImpl.d.ts

@@ -0,0 +1,5 @@
+import type { ResultModel, ResultModelFactory, ResultModelFactoryOptions } from "./api";
+export declare class ResultModelFactoryImpl implements ResultModelFactory {
+    private coordinateTransformer;
+    fromStoreAndQuery(options: ResultModelFactoryOptions): Promise<ResultModel>;
+}

package/result-api/ResultModelImpl.d.ts

@@ -0,0 +1,22 @@
+import { Evented } from "apprt-core/Events";
+import type { ResultModel, ResultModelEvents, TableModel } from "./api";
+/** Options for the constructor of {@link ResultModelImpl}. */
+export interface ResultModelOptions {
+    /** The initial set of table models. */
+    tables?: TableModel<any>[] | undefined;
+}
+/**
+ * A simple result model that manages a list of table models.
+ *
+ * The result model takes ownership of its tables: when a table has been
+ * added, it will be destroyed when it is being removed
+ * or if the result model is destroyed.
+ */
+export declare class ResultModelImpl extends Evented<ResultModelEvents> implements ResultModel {
+    #private;
+    constructor(options: ResultModelOptions);
+    get tables(): readonly TableModel[];
+    destroy(): void;
+    addTableModel(table: TableModel<any>): void;
+    removeTableModel(id: string): boolean;
+}

package/result-api/SelectionEventHandler.d.ts

@@ -0,0 +1,8 @@
+import { InjectedReference } from "apprt-core/InjectedReference";
+import type { CoordinateTransformer } from "coordinatetransformer/api";
+import type { OpenResultsService } from "./api";
+export declare class SelectionEventHandler {
+    resultService: InjectedReference<OpenResultsService>;
+    coordinateTransformer: InjectedReference<CoordinateTransformer>;
+    receive(event: any): void;
+}

package/result-api/StoreBackedTableModel.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="arcgis-js-api" />
+import type { CoordinateTransformer } from "coordinatetransformer/api";
+import type { SpatialReference } from "esri/geometry";
+import type { AllowedIdTypes, Store } from "store-api/api/Store";
+import { AbstractTableModel, MetadataResult } from "./AbstractTableModel";
+import type { ItemGeometry, LoadOptions, TableItem } from "./api";
+export interface StoreBackedTableModelOptions {
+    /** The unique id of this model. Defaults to the store id if not specified. */
+    id?: string;
+    /** Display title for this table model. */
+    title: string;
+    /** The original data source. */
+    store: Store<any>;
+    /** Fields that will be exposed to the UI. Use `undefined` to expose all store fields. */
+    visibleFields?: string[] | undefined;
+    /**
+     * Reference to a coordinate transformer to (optionally) transform geometries if
+     * the store does not return them in the correct spatial reference system.
+     */
+    coordinateTransformer?: CoordinateTransformer;
+    /**
+     * Retrieves the object ids of objects that shall be exposed by this model.
+     */
+    fetchObjectIds(): Promise<AllowedIdTypes[]>;
+}
+export declare class StoreBackedTableModel extends AbstractTableModel {
+    #private;
+    constructor(options: StoreBackedTableModelOptions);
+    protected loadMetadata(options: LoadOptions): Promise<MetadataResult>;
+    protected loadItems(): Promise<TableItem[]>;
+    loadGeometries(sr: SpatialReference): Promise<ItemGeometry[]>;
+}

package/result-api/TableActionResolverImpl.d.ts

@@ -0,0 +1,23 @@
+import type { TableActionDisplayStateProvider, BulkTableAction, TableActionResolverContext, RowTableAction, TableActionResolverContextOptions, TableActionResolver } from "./api";
+import type { InjectedReference } from "apprt-core/InjectedReference";
+import type ComponentContext from "system/component/ComponentContext";
+/**
+ * Default TableActionResolver.
+ * Registered as service in the injection system.
+ */
+export declare class TableActionResolverImpl implements TableActionResolver {
+    #private;
+    _componentContext: InjectedReference<ComponentContext>;
+    addActionDisplayStateProvider(provider: TableActionDisplayStateProvider): void;
+    removeActionDisplayStateProvider(provider: TableActionDisplayStateProvider): void;
+    addBulkTableAction(action: BulkTableAction, meta?: ActionMetadata): void;
+    removeBulkTableAction(action: BulkTableAction): void;
+    addRowTableAction(action: RowTableAction, meta?: ActionMetadata): void;
+    removeRowTableAction(action: RowTableAction): void;
+    createResolverContext(options: TableActionResolverContextOptions): TableActionResolverContext;
+}
+declare type ToolRules = any;
+interface ActionMetadata {
+    rules?: ToolRules;
+}
+export {};

package/result-api/actions/CsvConverter.d.ts

@@ -0,0 +1,18 @@
+interface CsvConverterOpts {
+    fields: Field[];
+    separator?: string;
+    fieldRenderer?: (fieldName: string, fieldValue: any) => string;
+}
+export declare type Row = (fieldName: string) => any;
+export interface Field {
+    name: string;
+    type: string;
+    title?: string;
+}
+export declare class CsvConverter {
+    #private;
+    constructor(opts: CsvConverterOpts);
+    convert(rows: AsyncIterable<Row>): Promise<string>;
+    private _escape;
+}
+export {};

package/result-api/actions/ExportCsvAction.d.ts

@@ -0,0 +1,15 @@
+import { BulkActionContext, BulkButtonTableAction } from "../api";
+export interface FileSaver {
+    save(content: unknown, filename: string, mimetype: string, charset: string): Promise<void>;
+}
+export declare class ExportCsvAction implements BulkButtonTableAction {
+    #private;
+    uiType: "button";
+    icon: string;
+    label: string;
+    tooltip: string;
+    id: string;
+    set fileSaver(value: FileSaver | undefined);
+    constructor(properties: Record<string, any>);
+    trigger(context: BulkActionContext): Promise<void>;
+}

package/result-api/actions/ZoomToItemAction.d.ts

@@ -0,0 +1,14 @@
+import type { RowActionContext, RowButtonTableAction, TableActionDisplayState, TableItem, TableModel } from "../api";
+import type { ActionService } from "map-actions/api";
+export declare class ZoomToItemAction implements RowButtonTableAction {
+    #private;
+    id: string;
+    uiType: "button";
+    label: string;
+    tooltip: string;
+    icon: string;
+    constructor(properties: Record<string, any>);
+    set mapActionService(srv: ActionService | undefined);
+    trigger(actionContext: RowActionContext): Promise<void>;
+    provideDisplayState(tableModel: TableModel, tableItem: TableItem): Partial<TableActionDisplayState>;
+}

package/result-api/actions/ZoomToSelectedAction.d.ts

@@ -0,0 +1,13 @@
+import type { BulkActionContext, BulkButtonTableAction } from "../api";
+import type { ActionService } from "map-actions/api";
+export declare class ZoomToSelectedAction implements BulkButtonTableAction {
+    #private;
+    id: string;
+    uiType: "button";
+    label: string;
+    tooltip: string;
+    icon: string;
+    set mapActionService(srv: ActionService | undefined);
+    constructor(properties: Record<string, any>);
+    trigger(actionContext: BulkActionContext): Promise<void>;
+}

package/result-api/api/actions.d.ts

@@ -0,0 +1,209 @@
+import type { TableItem, ItemGeometry, TableModel, ResultModel } from "./model";
+import type { EventSource } from "apprt-core/Events";
+/**
+ * All BulkTableAction types.
+ */
+export declare type BulkTableAction = BulkButtonTableAction;
+/**
+ * All RowTableAction types.
+ */
+export declare type RowTableAction = RowButtonTableAction;
+/**
+ * All currently supported UI types.
+ */
+export declare type TableActionUIType = "button";
+/**
+ * Base interface for BulkTableActions and RowTableActions.
+ */
+export interface TableAction {
+    /** ID used to identify this action. */
+    readonly id: string;
+    /** Type of action that describes how it is rendered, e.g. as a button **/
+    readonly uiType: TableActionUIType;
+}
+/**
+ * An action that is displayed as a button in a table's menu bar.
+ */
+export interface BulkButtonTableAction extends TableAction {
+    readonly uiType: "button";
+    /** Icon of the button that will be rendered in the menu bar. **/
+    readonly icon: string;
+    /** Label that might be rendered on a button beside or instead of the icon. **/
+    readonly label: string;
+    /** Tooltip that is displayed, when hovering the button. **/
+    readonly tooltip: string;
+    /**
+     * Runs the action code.
+     *
+     * @param actionContext the data the action can operate on.
+     **/
+    trigger(actionContext: BulkActionContext): Promise<void>;
+    /**
+     * Actions can optionally provide a display state that controls
+     * if this action is visible or enabled in a table's menu bar.
+     *
+     * @param tableModel the table model that requests the display state.
+     */
+    provideDisplayState?(tableModel: TableModel): Partial<TableActionDisplayState>;
+}
+/**
+ * An action that is displayed as a button in the row of all table item.
+ */
+export interface RowButtonTableAction extends TableAction {
+    readonly uiType: "button";
+    /** Icon of the button that will be rendered in the table row **/
+    readonly icon: string;
+    /** Label that might be rendered on a button beside or instead of the icon. **/
+    readonly label: string;
+    /** Tooltip that is displayed, when hovering the button. **/
+    readonly tooltip: string;
+    /**
+     * Runs the action code.
+     *
+     * @param actionContext the data the action can operate on.
+     **/
+    trigger(actionContext: RowActionContext): Promise<void>;
+    /**
+     * Actions can optionally provide a display state that controls
+     * if this action is visible or enabled for a specific table item.
+     *
+     * @param tableModel the table model that requests the display state.
+     * @param tableItem the current table item for the state is requested.
+     */
+    provideDisplayState?(tableModel: TableModel, tableItem: TableItem): Partial<TableActionDisplayState>;
+}
+/**
+ * Data that a {@link RowTableAction} can operate on.
+ */
+export interface RowActionContext {
+    /**
+     * The table model that the action is triggered for.
+     * The model provides access to items and metadata.
+     */
+    readonly model: TableModel;
+    /** Renders the given field value to a string. */
+    renderAsString(fieldName: string, value: any): string;
+    /** Provides the current active item, for which the action is triggered. Used for inline actions. **/
+    getActiveItem(): Promise<TableItem | undefined>;
+    /** Provides the current geometry of the active item **/
+    getGeometryOfActiveItem(): Promise<ItemGeometry | undefined>;
+}
+/**
+ * Data that a {@link BulkTableAction} can operate on.
+ */
+export interface BulkActionContext {
+    /**
+     * The table model that the action is triggered for.
+     * The model provides access to items and metadata.
+     */
+    readonly model: TableModel;
+    /** Renders the given field value to a string. */
+    renderAsString(fieldName: string, value: any): string;
+    /** Provides a subset of items, usually the selected items from a result-ui **/
+    getSelectedItems(): Promise<TableItem[]>;
+    /** Optional: returns geometries for currently selected items **/
+    getGeometriesForSelectedItems?(): Promise<ItemGeometry[]>;
+}
+/**
+ * Event specifiers for the {@link TableActionResolver}.
+ * <ul>
+ *      <li>Key: event name</li>
+ *      <li>Type: event type in event handler</li>
+ * </ul>
+ */
+export interface TableActionResolverContextEvents {
+    /** Emitted after an action was added or removed **/
+    "bulk-actions-changed": void;
+    /** Emitted after an row action was added or removed **/
+    "row-actions-changed": void;
+}
+/**
+ * A bridge and extension point between the requirements of a concrete UI to lookup actions
+ * and a dynamic rendering of actions in the UI.
+ */
+export interface TableActionResolver {
+    /**
+     * Creates a resolve context that provides access to actions.
+     *
+     * @param options the resolving options
+     */
+    createResolverContext(options: TableActionResolverContextOptions): TableActionResolverContext;
+}
+/**
+ * Options controlling the result of {@link TableActionResolver.createResolverContext}.
+ */
+export interface TableActionResolverContextOptions {
+    /**
+     * IDs of {@link BulkTableAction}s to resolve.
+     * The order of the IDs determines the order of the resolved actions.
+     * The expression `["*"]` gets all available actions in a implementation-specific order.
+     */
+    bulkActionIds: string[];
+    /**
+     * IDs of {@link RowTableAction}s to resolve.
+     * The order of the IDs determines the order of the resolved actions.
+     * The expression `["*"]` gets all available actions in a implementation-specific order.
+     */
+    rowActionIds: string[];
+    /**
+     * The current result model for which the actions should be resolved.
+     */
+    model: ResultModel;
+}
+/**
+ *  An object of this kind lives only for the time a concrete UI is displayed.
+ *  It provides a way to react to action state changes, e.g. when an action is hidden or deactivated.
+ *  Additionally, it provides a way to conditionally render row actions.
+ */
+export interface TableActionResolverContext extends EventSource<TableActionResolverContextEvents> {
+    /**
+     * Gets actions available for the TableModel.
+     */
+    getBulkActions(tableModel: TableModel): TableActionItem<BulkTableAction>[];
+    /**
+     * Gets actions available for the TableModel and TableItem.
+     */
+    getRowActions(tableModel: TableModel, tableItem: TableItem): TableActionItem<RowTableAction>[];
+    /**
+     * Must be called by a UI to indicate that the context is no longer required.
+     */
+    destroy(): void;
+}
+/**
+ * Links a {@link TableAction} to the "enabled" state.
+ */
+export interface TableActionItem<T extends TableAction> {
+    /** A TableAction */
+    action: T;
+    /**
+     * `true` if the action enabled.
+     */
+    enabled: boolean;
+}
+/**
+ * UI state of a {@link TableAction}.
+ */
+export interface TableActionDisplayState {
+    /**
+     * `true` if the corresponding action should be displayed. If `false`, the action is not displayed in the UI.
+     */
+    visible: boolean;
+    /**
+     * `true` if the corresponding action should be rendered as "clickable" (if visible).
+     * If `false` the action is rendered disabled.
+     */
+    enabled: boolean;
+}
+/** Used by the {@link TableActionResolver} implementation to allow the customization
+ *  of the visible and enabled states of a row action.
+ */
+export interface TableActionDisplayStateProvider {
+    /**
+     * Provides the UI state information for an action.
+     * @param actionId ID of the action to decide upon.
+     * @param tableModel the current table model.
+     * @param tableItem the current table item. `undefined` if the state is requested for a {@link BulkTableAction}.
+     * @returns the state. `undefined` if no state could be provided.
+     */
+    provideDisplayState(actionId: string, tableModel: TableModel, tableItem?: TableItem): Partial<TableActionDisplayState> | undefined;
+}

package/result-api/api/{all.d.ts → index.d.ts}

@@ -1,3 +1,4 @@
 export * from "./model";
 export * from "./service";
 export * from "./ui";
+export * from "./actions";