@luomus/laji-form 14.3.8 → 15.1.0

package/playwright.config.ts

@@ -0,0 +1,77 @@
+import { defineConfig, devices } from '@playwright/test';
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// require('dotenv').config();
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+  testDir: './test',
+  /* Run tests in files in parallel */
+  fullyParallel: true,
+  /* Fail the build on CI if you accidentally left test.only in the source code. */
+  forbidOnly: !!process.env.CI,
+  /* Retry on CI only */
+  retries: process.env.CI ? 2 : 0,
+  /* Opt out of parallel tests on CI. */
+  workers: process.env.CI ? 1 : undefined,
+  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+  reporter: 'line',
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    /* Base URL to use in actions like `await page.goto('/')`. */
+    baseURL: 'http://127.0.0.1:8083',
+
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: 'on-first-retry',
+  },
+
+  /* Configure projects for major browsers */
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+
+    // {
+    //   name: 'webkit',
+    //   use: { ...devices['Desktop Safari'] },
+    // },
+
+    /* Test against mobile viewports. */
+    // {
+    //   name: 'Mobile Chrome',
+    //   use: { ...devices['Pixel 5'] },
+    // },
+    // {
+    //   name: 'Mobile Safari',
+    //   use: { ...devices['iPhone 12'] },
+    // },
+
+    /* Test against branded browsers. */
+    // {
+    //   name: 'Microsoft Edge',
+    //   use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    // },
+    // {
+    //   name: 'Google Chrome',
+    //   use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    // },
+  ],
+
+  /* Run your local dev server before starting the tests */
+  // webServer: {
+  //   command: 'npm run start',
+  //   url: 'http://127.0.0.1:3000',
+  //   reuseExistingServer: !process.env.CI,
+  // },
+});

package/q

@@ -0,0 +1,196 @@
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/components.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/components.js:360 @ export class Stretch extends React.Component {
+	}
+
+	invalidate = (callback) => {
+		console.log('invalidate');
+		this.update(this.getState(), callback);
+	}
+
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/EnumRangeArrayField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/EnumRangeArrayField.js:8 @ import BaseComponent from "../BaseComponent";
+import { getUiOptions } from "../../utils";
+import { Autosuggest } from "../widgets/AutosuggestWidget";
+import { TagInputComponent } from "./TagArrayField";
+const equals = require("deep-equal");
+
+@BaseComponent
+export default class EnumRangeArrayField extends React.Component {
+@ src/components/fields/EnumRangeArrayField.js:30 @ export default class EnumRangeArrayField extends React.Component {
+		this.state = {value: ""};
+	}
+
+	UNSAFE_componentWillReceiveProps(props) {
+		if (!equals(props.formData, this.props.formData)) {
+			this.props.formContext.services.customEvents.send(props.idSchema.$id, "resize");
+		}
+	}
+ 
+	setRef = (elem) => {
+		this.autosuggestRef = elem;
+	}
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/ImageArrayField.tsx
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/ImageArrayField.tsx:209 @ export function MediaArrayField<LFC extends Constructor<React.Component<FieldPro
+			this.mounted = false;
+		}
+
+		componentDidUpdate(prevProps: FieldProps, prevState: MediaArrayState) {
+			const getCount = (_props: FieldProps, _state: MediaArrayState) => ((_props.formData || []).length + (_state.tmpMedias || []).length);
+ 
+			if (getCount(prevProps, prevState) !== getCount(this.props, this.state)) {
+				this.props.formContext.services.customEvents.send(this.props.idSchema.$id, "resize");
+			}
+		}
+ 
+		onDragEnter = () => {this.setState({dragging: true});};
+
+		onDragLeave = () => {this.setState({dragging: false});};
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/MapArrayField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/MapArrayField.js:1159 @ class _MapArrayField extends ComposedComponent { // eslint-disable-line indent
+			this._tileLayerNameOnNextTick = tileLayerOptions;
+			this._tileLayerNameOnNextTickCallback = callback;
+		};
+		this._resizeEventHandler = () => {
+			this.refs.stretch.invalidate();
+		};
+		this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "activeIdx", this._setActiveEventHandler);
+		this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "zoomToData", this._zoomToDataEventHandler);
+		this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "tileLayers", this._tileLayersEventHandler);
+		this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "resize", this._resizeEventHandler);
+
+		if (this.state.activeIdx !== undefined) {
+			this.afterActiveChange(this.state.activeIdx, !!"initial call");
+@ src/components/fields/MapArrayField.js:1179 @ class _MapArrayField extends ComposedComponent { // eslint-disable-line indent
+		this.props.formContext.services.customEvents.remove(this.props.idSchema.$id, "activeIdx", this._setActiveEventHandler);
+		this.props.formContext.services.customEvents.remove(this.props.idSchema.$id, "zoomToData", this._zoomToDataEventHandler);
+		this.props.formContext.services.customEvents.remove(this.props.idSchema.$id, "tileLayers", this._tileLayersEventHandler);
+		this.props.formContext.services.customEvents.remove(this.props.idSchema.$id, "resize", this._resizeEventHandler);
+	}
+
+	componentDidUpdate(...params) {
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/SchemaField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/SchemaField.js:112 @ export default class _SchemaField extends React.Component {
+		};
+	}
+
+	componentDidUpdate(prevProps) {
+		if (!deepEquals(prevProps.errorSchema, this.props.errorSchema)) {
+			this.props.registry.formContext.services.customEvents.send(this.props.idSchema.$id, "resize");
+		}
+	}
+ 
+	render() {
+		const props = this.functionOutputProps || this.props;
+		let {schema, uiSchema = {}, formContext, registry, ..._props} = props; // eslint-disable-line @typescript-eslint/no-unused-vars
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/ScopeField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/ScopeField.js:138 @ export default class ScopeField extends React.Component {
+		}
+		if (!equals(prevState.fieldsToShow, this.state.fieldsToShow)) {
+			this.props.formContext.utils.syncScroll();
+			this.props.formContext.services.customEvents.send(this.props.idSchema.$id, "resize");
+		}
+	}
+
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/SingleActiveArrayField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/SingleActiveArrayField.js:678 @ class TableArrayFieldTemplate extends React.Component {
+		super(props);
+		this.state = {};
+		this.itemElems = [];
+		this.resizeObserver = new ResizeObserver(this.onResize);
+	}
+
+	onResize = (data, callback) => {
+		this.updateLayout(null, callback);
+	onResize = () => {
+		this.updateLayout();
+	}
+
+	componentDidMount() {
+		this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "resize", this.onResize);
+		this._updateRenderingMode = () => this.updateRenderingMode();
+		window.addEventListener("resize", this._updateRenderingMode);
+		this.updateRenderingMode();
+@ src/components/fields/SingleActiveArrayField.js:694 @ class TableArrayFieldTemplate extends React.Component {
+
+	componentWillUnmount() {
+		window.removeEventListener("resize", this._updateRenderingMode);
+		this.props.formContext.services.customEvents.remove(this.props.idSchema.$id, "resize", this.onResize);
+		this.resizeObserver.disconnect();
+	}
+
+	componentDidUpdate(prevProps, prevState) {
+@ src/components/fields/SingleActiveArrayField.js:726 @ class TableArrayFieldTemplate extends React.Component {
+			if (tHeadHeight) this.prevTHeadHeight = tHeadHeight;
+			this._prevCheckedLength = this.props.items.length;
+		}
+ 
+		if (this.props.idSchema.$id !== prevProps.idSchema.$id) {
+			prevProps.formContext.services.customEvents.remove(prevProps.idSchema.$id, "resize", this.onResize);
+			this.props.formContext.services.customEvents.add(this.props.idSchema.$id, "resize", this.onResize);
+			this.updateLayout();
+		}
+	}
+
+	// Sets state.normalRendering on if screen is too small for table layout.
+@ src/components/fields/SingleActiveArrayField.js:775 @ class TableArrayFieldTemplate extends React.Component {
+
+	setActiveRef = (elem) => {
+		this.activeElem = elem;
+		this.activeElem && this.resizeObserver.observe(this.activeElem);
+	}
+
+	setTHeadRef = (elem) => {
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/fields/TagArrayField.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/fields/TagArrayField.js:6 @ import { findDOMNode } from "react-dom";
+import * as PropTypes from "prop-types";
+import { isEmptyString, getUiOptions, triggerParentComponent } from "../../utils";
+import BaseComponent from "../BaseComponent";
+const equals = require("deep-equal");
+
+@BaseComponent
+export default class TagArrayField extends React.Component {
+@ src/components/fields/TagArrayField.js:43 @ export class TagInputComponent extends React.Component {
+		this.setState(this.getStateFromProps(props));
+	}
+
+	componentDidUpdate(prevProps) {
+		if (!equals(prevProps.formData, this.props.formData)) {
+			this.props.formContext.services.customEvents.send(this.props.idSchema.$id, "resize");
+		}
+	}
+ 
+	getStateFromProps = ({value}) => {
+		return {value};
+	}
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+modified: src/components/templates/ArrayFieldTemplate.js
+───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+@ src/components/templates/ArrayFieldTemplate.js:13 @ import { getTemplate } from "@rjsf/utils";
+function onAdd(e, props) {
+	if (!canAdd(props)) return;
+	props.onAddClick(e);
+	setTimeout(() => props.formContext.services.customEvents.send(props.idSchema.$id, "resize"));
+}
+
+export const onDelete = (item, props) => (e) => {
+	item.onDropIndexClick(item.index)(e);
+	setTimeout(() => props.formContext.services.customEvents.send(props.idSchema.$id, "resize"));
+};
+
+export function beforeAdd(props) {

package/rename.sh

@@ -0,0 +1,24 @@
+mv array-spec.ts array.spec.ts
+mv bird-point-count-spec.ts sbird-point-count.spec.ts
+mv collection-contest-form-spec.ts collection-contest-form.spec.ts
+mv dataset-form-spec.ts dataset-form.spec.ts
+mv date-time-widget-spec.ts date-time-widget.spec.ts
+mv geocoder-spec.ts geocoder.spec.ts
+mv image-array-spec.ts image-array.spec.ts
+mv inject-field-spec.ts inject-field.spec.ts
+mv internal-uuids-spec.ts internal-uuids.spec.ts
+mv invasive-species-eradication-np-spec.ts invasive-species-eradication-np.spec.ts
+mv invasive-species-eradication-spec.ts invasive-species-eradication.spec.ts
+mv line-transect-spec.ts line-transect.spec.ts
+mv mobile-form-spec.ts mobile-form.spec.ts
+mv nafi-spec.ts nafi.spec.ts
+mv select-widget-spec.ts select-widget.spec.ts
+mv single-item-array-field-spec.ts single-item-array-field.spec.ts
+mv syke-butterfly-spec.ts syke-butterfly.spec.ts
+mv transaction-form-spec.ts transaction-form.spec.ts
+mv trip-report-autosuggest-spec.ts trip-report-autosuggest.spec.ts
+mv trip-report-spec.ts trip-report.spec.ts
+mv unit-list-shorthand-array-field-spec.ts unit-list-shorthand-array-field.spec.ts
+mv validation-spec.ts validation.spec.ts
+mv water-bird-spec.ts water-bird.spec.ts
+mv wbc-spec.ts wbc.spec.ts

package/test-export/test-utils.d.ts

@@ -1,53 +1,32 @@
-import { ElementFinder, ElementArrayFinder } from "protractor";
+import { Locator, Page } from "@playwright/test";
 import { JSONSchema7 } from "json-schema";
-export declare const EC: import("protractor").ProtractorExpectedConditions;
-export declare const getLocatorForContextId: (contextId: number) => (path: string) => string;
-export declare const emptyForm: (params?: string) => Promise<any>;
-export declare const navigateToForm: (formID: string, params?: string) => Promise<any>;
+import { LajiFormState } from "@luomus/laji-form/lib/components/LajiForm";
+import type { JSONSerializable } from "@luomus/laji-form/lib/utils";
+import { MapPageObject } from "@luomus/laji-map/test-export/test-utils";
+export declare const emptyForm: (page: Page, params?: string) => Promise<import("playwright-core").Response | null>;
+export declare const navigateToForm: (page: Page, formID: string, params?: string) => Promise<import("playwright-core").Response | null>;
 export declare const lajiFormLocator: (path: string) => string;
-export declare const lajiFormLocate: (str: string) => ElementFinder;
-export declare const getFocusedElement: () => import("selenium-webdriver").WebElementPromise;
-export declare const getFocusedId: () => import("selenium-webdriver").promise.Promise<string>;
+export declare const getFocusedElement: (page: Page) => Locator;
 export interface Mock {
     resolve: (response?: any, raw?: boolean) => Promise<void>;
     reject: (response?: any, raw?: boolean) => Promise<void>;
     remove: () => Promise<void>;
 }
-export interface DateWidgetPO {
-    $container: ElementFinder;
-    $input: ElementFinder;
-    buttons: {
-        $today: ElementFinder;
-        $yesterday: ElementFinder;
-        $same: ElementFinder;
-        $date: ElementFinder;
-        $time: ElementFinder;
-    };
-    calendar: {
-        $today: ElementFinder;
-        waitAnimation: () => Promise<void>;
-    };
-    clock: {
-        "$01:00": ElementFinder;
-        waitAnimation: () => Promise<void>;
-    };
-}
-export interface BooleanWidgetPO {
-    $container: ElementFinder;
-    $true: ElementFinder;
-    $false: ElementFinder;
-    $undefined: ElementFinder;
-    $active: ElementFinder;
-    $nonactive: ElementFinder;
-}
-export interface EnumWidgetPOI {
-    $container: ElementFinder;
+export declare type ImageArrayFieldPO = ReturnType<Form["getImageArrayField"]>;
+export declare type TaxonAutosuggestWidgetPO = ReturnType<Form["getTaxonAutosuggestWidget"]>;
+export declare type UnitListShorthandArrayFieldPO = ReturnType<Form["getUnitListShorthandArrayField"]>;
+export declare type EnumWidgetPO = ReturnType<typeof getEnumWidgetForContainer>;
+export declare type DateWidgetPO = ReturnType<Form["getDateWidget"]>;
+export declare type BooleanWidgetPO = ReturnType<Form["getBooleanWidget"]>;
+export declare type NamedPlaceChooserPO = ReturnType<Form["getNamedPlaceChooser"]>;
+declare function getEnumWidgetForContainer($container: Locator): {
+    $container: Locator;
     openEnums: () => Promise<void>;
-    $enumContainer: ElementFinder;
-    $$enums: ElementArrayFinder;
-    $input: ElementFinder;
-}
-interface FormProps {
+    $enumContainer: Locator;
+    $enums: Locator;
+    $input: Locator;
+};
+interface DemoPageProps {
     schema?: JSONSchema7;
     uiSchema?: any;
     formData?: any;
@@ -58,127 +37,175 @@ interface FormProps {
     localFormData?: boolean | string;
 }
 export declare class Form {
-    props: FormProps;
-    contextId: number;
-    constructor(params?: FormProps);
-    initialize(beforeInit?: (form: Form) => Promise<void>, contextId?: number): Promise<void>;
-    e(path: string): Promise<any>;
-    setState(state: any): Promise<any>;
-    getState(): Promise<any>;
-    submit(): Promise<void>;
-    startSubmit(): Promise<void>;
-    submitOnlySchemaValidations(): Promise<void>;
-    waitUntilBlockingLoaderHides(timeout?: number): import("selenium-webdriver").promise.Promise<unknown>;
-    getSubmittedData(): Promise<any>;
-    getChangedData(): Promise<any>;
-    getPropsData(): Promise<any>;
-    $form: ElementFinder;
-    $locate(path: string): ElementFinder;
-    $locateButton(path: string, selector: string): ElementFinder;
-    $locateAddition(path: string, selector: string): ElementFinder;
-    getMockStr: (path: string, query: any) => string;
-    setMockResponse(path: string, query?: any): Promise<Mock>;
-    createMockResponseQueue(path: string, query?: any): Promise<{
-        create: () => Promise<{
-            resolve: (response: any, raw?: boolean | undefined) => import("selenium-webdriver").promise.Promise<unknown>;
-            reject: (response: any, raw?: boolean | undefined) => import("selenium-webdriver").promise.Promise<unknown>;
-        }>;
-        remove: () => import("selenium-webdriver").promise.Promise<unknown>;
-    }>;
+    protected page: Page;
+    protected $locator: Locator;
+    constructor(page: Page, $locator?: Locator);
+    $form: Locator;
+    /** Locates a field with a dot separated identifier, e.g. "gatherings.0.units.1" */
+    $locate(path: string): Locator;
+    /** Locates a button for a field with a dot separated identifier, e.g. "gatherings.0.units.1" */
+    $locateButton(path: string, selector: string, locateFromBody?: boolean): Locator;
+    /** Locates some additional element for a field with a dot separated identifier, e.g. "gatherings.0.units.1" */
+    $locateAddition(path: string, selector: string, locateFromBody?: boolean): Locator;
     createValidatorPO: (type: "error" | "warning") => {
-        $$all: ElementArrayFinder;
-        $panel: ElementFinder;
+        $all: Locator;
+        $panel: Locator;
     };
     errors: {
-        $$all: ElementArrayFinder;
-        $panel: ElementFinder;
+        $all: Locator;
+        $panel: Locator;
     };
     warnings: {
-        $$all: ElementArrayFinder;
-        $panel: ElementFinder;
+        $all: Locator;
+        $panel: Locator;
     };
     failedJobs: {
-        $container: ElementFinder;
+        $container: Locator;
+        $errors: Locator;
+    };
+    $runningJobs: Locator;
+    $acknowledgeWarnings: Locator;
+    $blocker: Locator;
+    $mapFieldFullscreenMap: Locator;
+    getBooleanWidget(str: string): {
+        $container: Locator;
+        $true: Locator;
+        $false: Locator;
+        $undefined: Locator;
+        $active: Locator;
+        $nonactive: Locator;
+    };
+    $getInputWidget(str: string): Locator;
+    $getTextareaWidget(str: string): Locator;
+    $getEnumWidget(str: string): {
+        $container: Locator;
+        openEnums: () => Promise<void>;
+        $enumContainer: Locator;
+        $enums: Locator;
+        $input: Locator;
+    };
+    getDateWidget(str: string): {
+        $container: Locator;
+        $input: Locator;
+        buttons: {
+            $today: Locator;
+            $yesterday: Locator;
+            $same: Locator;
+            $date: Locator;
+            $time: Locator;
+        };
+        calendar: {
+            $today: Locator;
+        };
+        clock: {
+            "$01:00": Locator;
+        };
+    };
+    $getFieldErrors(str: string): Locator;
+    getImageArrayField: (lajiFormLocator: string) => {
+        $container: Locator;
+        $imgContainers: Locator;
+        $imgs: Locator;
+        $imgLoading: Locator;
+        $imgRemoves: Locator;
+        $imgRemoveConfirmButton: (id: string) => Locator;
+        $dropzone: Locator;
+        $modal: Locator;
+        $addModal: Locator;
+        $modalClose: Locator;
+        $addModalCancel: Locator;
+    };
+    getTaxonAutosuggestWidget: (lajiFormLocator: string) => {
+        $input: Locator;
+        $suggestionsContainer: Locator;
+        $suggestions: Locator;
+        $getGlyph: (glyph: string) => Locator;
+        $suggestedGlyph: Locator;
+        $nonsuggestedGlyph: Locator;
+        $powerUserButton: Locator;
     };
-    $acknowledgeWarnings: ElementFinder;
-    isBlocked: () => import("selenium-webdriver").promise.Promise<boolean>;
-    mockImageUpload: (lajiFormLocator: string) => Promise<{
-        resolve: () => Promise<void>;
-        remove: () => Promise<void>;
-    }>;
-    getBooleanWidget(str: string): BooleanWidgetPO;
-    $getInputWidget(str: string): ElementFinder;
-    $getTextareaWidget(str: string): ElementFinder;
-    $getEnumWidget(str: string): EnumWidgetPOI;
-    getDateWidget(str: string): DateWidgetPO;
-    $$getFieldErrors(str: string): ElementArrayFinder;
-    _getImageArrayField: (form: Form) => (lajiFormLocator: string) => ImageArrayFieldPOI;
-    getImageArrayField: (lajiFormLocator: string) => ImageArrayFieldPOI;
-    _getTaxonAutosuggestWidget: (form: Form) => (lajiFormLocator: string) => TaxonAutosuggestWidgetPOI;
-    getTaxonAutosuggestWidget: (lajiFormLocator: string) => TaxonAutosuggestWidgetPOI;
     getScopeField: (lajiFormLocator: string) => {
-        $button: ElementFinder;
-        $$listItems: ElementArrayFinder;
+        $button: Locator;
+        $listItems: Locator;
+        modal: {
+            $container: Locator;
+            $close: Locator;
+            $loadingGroup: Locator;
+            $groupTitles: Locator;
+            $listItems: Locator;
+        };
     };
-    getUnitListShorthandArrayField: (lajiFormLocator: string) => UnitListShorthandArrayFieldPOI;
-}
-export declare const isDisplayed: ($elem: ElementFinder) => Promise<boolean>;
-export interface ImageArrayFieldPOI {
-    $container: ElementFinder;
-    $$imgs: ElementArrayFinder;
-    $$imgInteractives: ElementArrayFinder;
-    $$imgRemoves: ElementArrayFinder;
-    $imgRemoveConfirmButton: (id: string) => ElementFinder;
-    $dropzone: ElementFinder;
-    $modal: ElementFinder;
-    $modalClose: ElementFinder;
-}
-export interface TaxonAutosuggestWidgetPOI {
-    $input: ElementFinder;
-    $suggestionsContainer: ElementFinder;
-    $$suggestions: ElementArrayFinder;
-    waitForSuggestionsToLoad: () => Promise<void>;
-    waitForGlyph: () => Promise<void>;
-    isSuggested: () => Promise<boolean>;
-    isNonsuggested: () => Promise<boolean>;
-    $powerUserButton: ElementFinder;
-    powerUserButtonIsActive: () => Promise<boolean>;
-    waitForPopoverToHide: () => Promise<void>;
-}
-export interface UnitListShorthandArrayFieldPOI {
-    $button: ElementFinder;
-    modal: {
-        $input: ElementFinder;
-        $addButton: ElementFinder;
+    getLocationChooser: (lajiFormLocator: string) => {
+        $button: Locator;
+        modal: {
+            $container: Locator;
+            map: MapPageObject;
+        };
+        peeker: {
+            $popover: Locator;
+            $map: Locator;
+            $markers: Locator;
+        };
     };
-}
-export declare class NamedPlaceChooserPO {
-    select: EnumWidgetPOI;
-    mapPopup: {
-        $container: ElementFinder;
-        $useBtn: ElementFinder;
+    getUnitListShorthandArrayField: (lajiFormLocator: string) => {
+        $button: Locator;
+        modal: {
+            $input: Locator;
+            $addButton: Locator;
+        };
+    };
+    /** Draws a marker to the center of a laji-map rendered to the given locator. The locator defaults to "gatherings" */
+    putMarkerToMap(lajiFormLocator?: string): Promise<void>;
+    updateValue($input: Locator, value: string, blur?: boolean): Promise<void>;
+    $getShortHandWidget: (lajiFormLocator: string) => Locator;
+    getGeocoder: (lajiFormLocator?: string) => {
+        $btn: Locator;
+        $spinner: Locator;
+    };
+    getNamedPlaceChooser: () => {
+        select: {
+            $container: Locator;
+            openEnums: () => Promise<void>;
+            $enumContainer: Locator;
+            $enums: Locator;
+            $input: Locator;
+        };
+        mapPopup: {
+            $container: Locator;
+            $useBtn: Locator;
+        };
+        $alert: Locator;
+        $close: Locator;
     };
-    $alert: ElementFinder;
-    $close: ElementFinder;
 }
-export declare function createForm(props?: FormProps, beforeInit?: (form: Form) => Promise<void>): Promise<Form>;
-export declare function waitUntilBlockingLoaderHides(timeout?: number): import("selenium-webdriver").promise.Promise<unknown>;
-export declare function putForeignMarkerToMap(): Promise<void>;
-export declare function removeUnit(gatheringIdx: number, unitIdx: number): Promise<void>;
-export declare const updateValue: ($input: ElementFinder, value: string, blur?: boolean) => Promise<void>;
-export declare const mockImageMetadata: {
-    id: string;
-    capturerVerbatim: string[];
-    intellectualOwner: string;
-    intellectualRights: string;
-    fullURL: string;
-    largeURL: string;
-    squareThumbnailURL: string;
-    thumbnailURL: string;
-    originalURL: string;
-    uploadedBy: string;
-    "@context": string;
-};
+export declare class DemoPageForm extends Form {
+    props: DemoPageProps;
+    constructor(page: Page, params?: DemoPageProps);
+    initialize(beforeInit?: (form: DemoPageForm) => Promise<void>): Promise<void>;
+    e<T>(path: string): Promise<T>;
+    setState(state: any): Promise<unknown>;
+    getState(): Promise<Pick<LajiFormState, "formData">>;
+    submit(): Promise<void>;
+    submitOnlySchemaValidations(): Promise<unknown>;
+    getSubmittedData(): Promise<JSONSerializable>;
+    getChangedData(): Promise<JSONSerializable>;
+    getPropsData(): Promise<JSONSerializable>;
+    getMockStr: (path: string, query: any) => string;
+    setMockResponse(path: string, query?: any): Promise<Mock>;
+    createMockResponseQueue(path: string, query?: any): Promise<{
+        create: () => Promise<{
+            resolve: (response: any, raw?: boolean | undefined) => Promise<unknown>;
+            reject: (response: any, raw?: boolean | undefined) => Promise<unknown>;
+        }>;
+        remove: () => Promise<unknown>;
+    }>;
+    mockImageUpload: (lajiFormLocator: string) => Promise<{
+        resolve: () => Promise<void>;
+        remove: () => Promise<void>;
+    }>;
+}
+export declare function createForm(page: Page, props?: DemoPageProps, beforeInit?: (form: Form) => Promise<void>): Promise<DemoPageForm>;
 export declare const filterUUIDs: (any: any) => any;
 export declare const maybeJSONPointerToLocator: (pointer: string) => string;
+export declare const getRemoveUnit: (page: Page) => (gatheringIdx: number, unitIdx: number) => Promise<void>;
 export {};