@esri/solutions-components 1.1.0-next.20250917.1 → 1.1.0-next.20250917.3

package/dist/components/create-feature/customElement.d.ts

@@ -6,33 +6,131 @@ import { PublicLitElement as LitElement, TargetedEvent, JsxNode } from '@arcgis/
 
 type ICurrentPage = 'drawing' | 'editing' | 'featureForm' | 'templatePicker';
 export declare class CreateFeature extends LitElement {
+    /**
+     * boolean: Set this to true when have a custom submit button in the app.
+     * This will hide the header and footer elements of the editor and user needs to execute the submit method manually.
+     *
+     * @default false
+     */
     customizeSubmit?: boolean;
+    /**
+     * boolean: When true the Search box will be displayed
+     *
+     * @default false
+     */
     enableSearch?: boolean;
+    /**
+     * When true the snapping options will be exposed
+     *
+     * @default false
+     */
     enableSnapping: boolean;
+    /**
+     * string: selected floor level
+     *
+     * @default ''
+     */
     floorLevel: string;
+    /** string: selected floor level */
     formElements: any;
+    /**
+     * boolean: When true the application will be in mobile mode, controls the mobile or desktop view
+     *
+     * @default false
+     */
     isMobile: boolean;
+    /** esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */
     mapView: __esri.MapView | undefined;
+    /** ISearchConfiguration: Configuration details for the Search widget */
     searchConfiguration: ISearchConfiguration | undefined;
+    /**
+     * string: Layer id of the feature layer in which the new feature is to be created
+     *
+     * @default ''
+     */
     selectedLayerId: string;
+    /**
+     * boolean: When true the notice message with the current state should be shown
+     *
+     * @default true
+     */
     showGuidingMsg?: boolean;
+    /**
+     * string: Text to be displayed that will allow user to know they can submit new reports
+     *
+     * @default ''
+     */
     submitNewReportsMessage: string;
+    /**
+     * boolean: When true the map should shown in the editor component in mobile mode (while drawing graphic)
+     *
+     * @default false
+     */
     updateMapPosition: boolean;
+    /**
+     * boolean: When true reporting area layer should be honored if it exists
+     *
+     * @default false
+     */
     reportingArea: boolean;
+    /**
+     * string: polygon layer for the reporting feature
+     *
+     * @default ''
+     */
     reportingAreaLayer?: string | undefined;
+    /**
+     * string: Message to be displayed when feature is outside the reportingAreaLayer
+     *
+     * @default ''
+     */
     reportingAreaMessage: string;
+    /**
+     * boolean: When true Editor's sketch widgets will be displayed
+     *
+     * @default false
+     */
     showSketchWidgets: boolean;
+    /**
+     * boolean: When true user can create multiple features
+     *
+     * @default false
+     */
     allowMultipleCreation: boolean;
+    /**
+     * boolean: When true clicking on a feature on the map will display a popup
+     *
+     * @default false
+     */
     popupEnabled: boolean;
+    /**
+     * Submit the created feature
+     *
+     * @returns Promise that resolves when the operation is complete
+     */
     submit(): Promise<void>;
+    /**
+     * Refreshes the editor state, optionally updating the floor level.
+     *
+     * @param floorLevel - (Optional) The floor level to set. If provided, the editor updates to this floor level.
+     * @returns A promise that resolves when the refresh operation is complete.
+     */
     refresh(floorLevel?: string): Promise<void>;
+    /** Shows feature form */
     showForm(): Promise<void>;
+    /** Emitted on demand when the feature is created successfully */
     readonly success: TargetedEvent<this, void>;
+    /** Emitted on demand when the feature creation is failed */
     readonly fail: TargetedEvent<this, Error>;
+    /** Emitted on demand when drawing is completed */
     readonly drawComplete: TargetedEvent<this, boolean>;
+    /** Emitted on demand when in editing mode */
     readonly editingLocation: TargetedEvent<this, void>;
+    /** Emitted on demand when editing attachments */
     readonly editingAttachment: TargetedEvent<this, boolean>;
+    /** Emitted on demand when editor panel changes */
     readonly progressStatus: TargetedEvent<this, number>;
+    /** Emitted on switched form mobile to desktop or vice versa */
     readonly modeChanged: TargetedEvent<this, void>;
 }
 export {};

package/dist/components/create-feature/customElement.js

@@ -7,7 +7,7 @@ import { createRef as p, ref as m } from "lit-html/directives/ref.js";
 import { LitElement as L, createEvent as l, noShadowRoot as V, safeClassMap as u } from "@arcgis/lumina";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/1.1/esri/copyright.txt for details.
-v1.1.0-next.20250917.1 */
+v1.1.0-next.20250917.3 */
 const E = b`@layer{/** @license
  * Copyright 2025 Esri
  *
@@ -336,4 +336,3 @@ _("create-feature", S);
 export {
   S as CreateFeature
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"customElement.js","sources":["../../../src/components/create-feature/create-feature.tsx"],"sourcesContent":["/**\r\n * @license\r\n * Copyright 2025 Esri\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport { loadModules } from '../../utils/loadModules';\r\nimport { getAllFeatureLayers, getLayerOrTable } from '../../utils/mapViewUtils';\r\nimport type T9nStrings from './assets/t9n/messages.en.json';\r\nimport type { ILocatorSourceConfigItem, ISearchConfiguration } from '../../utils/interfaces';\r\nimport { useT9n } from '../../controllers/useT9n';\r\nimport type { PropertyValues } from 'lit';\r\nimport { createRef } from 'lit-html/directives/ref.js';\r\nimport {\r\n  LitElement,\r\n  property,\r\n  createEvent,\r\n  Fragment,\r\n  h,\r\n  method,\r\n  noShadowRoot,\r\n  state,\r\n} from '@arcgis/lumina';\r\nimport type {\r\n  JsxNode,\r\n} from '@arcgis/lumina';\r\nimport { styles } from './create-feature.css';\r\n\r\ndeclare global {\r\n  interface DeclareElements {\r\n    'create-feature': CreateFeature;\r\n  }\r\n}\r\n\r\ntype ICurrentPage = 'drawing' | 'editing' | 'featureForm' | 'templatePicker';\r\n\r\nexport class CreateFeature extends LitElement {\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Overrides (internal)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  static override styles = styles;\r\n\r\n  static override shadowRootOptions = noShadowRoot;\r\n\r\n  /** TODO: [MIGRATION] Consider inlining some of the watch functions called inside of this method to reduce boilerplate code */\r\n  override willUpdate(changes: PropertyValues<this>): void {\r\n    /* TODO: [MIGRATION] First time Lit calls willUpdate(), changes will include not just properties provided by the user, but also any default values your component set.\r\n    To account for this semantics change, the checks for (this.hasUpdated || value != defaultValue) was added in this method\r\n    Please refactor your code to reduce the need for this check.\r\n    Docs: https://qawebgis.esri.com/components/lumina/transition-from-stencil#watching-for-property-changes */\r\n\r\n    if (changes.has('mapView') && this.hasUpdated) {\r\n      void this.mapViewWatchHandler();\r\n    }\r\n\r\n    if (changes.has('isMobile') && this.hasUpdated) {\r\n      void this.isMobileHandler();\r\n    }\r\n\r\n    if (changes.has('_editorLoading') && (this.hasUpdated || this._editorLoading !== false)) {\r\n      void this._editorLoadingWatchHandler(this._editorLoading);\r\n    }\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Properties (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /**\r\n   * boolean: Set this to true when have a custom submit button in the app.\r\n   * This will hide the header and footer elements of the editor and user needs to execute the submit method manually.\r\n   */\r\n  @property() customizeSubmit?: boolean = false;\r\n\r\n  /** boolean: When true the Search box will be displayed */\r\n  @property() enableSearch?: boolean = false;\r\n\r\n  /** When true the snapping options will be exposed */\r\n  @property() enableSnapping = false;\r\n\r\n  /** string: selected floor level */\r\n  @property() floorLevel = '';\r\n\r\n  /** string: selected floor level */\r\n  @property() formElements: any;\r\n\r\n  /** boolean: When true the application will be in mobile mode, controls the mobile or desktop view */\r\n  @property() isMobile = false;\r\n\r\n  /** esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */\r\n  @property() mapView: __esri.MapView | undefined;\r\n\r\n  /** ISearchConfiguration: Configuration details for the Search widget */\r\n  @property() searchConfiguration: ISearchConfiguration | undefined;\r\n\r\n  /** string: Layer id of the feature layer in which the new feature is to be created */\r\n  @property() selectedLayerId = '';\r\n\r\n  /** boolean: When true the notice message with the current state should be shown */\r\n  @property() showGuidingMsg?: boolean = true;\r\n\r\n  /** string: Text to be displayed that will allow user to know they can submit new reports */\r\n  @property() submitNewReportsMessage = '';\r\n\r\n  /** boolean: When true the map should shown in the editor component in mobile mode (while drawing graphic) */\r\n  @property() updateMapPosition = false;\r\n\r\n  /** boolean: When true reporting area layer should be honored if it exists */\r\n  @property() reportingArea = false;\r\n\r\n  /**string: polygon layer for the reporting feature */\r\n  @property() reportingAreaLayer? = '';\r\n\r\n  /** string: Message to be displayed when feature is outside the reportingAreaLayer */\r\n  @property() reportingAreaMessage = '';\r\n\r\n  /** boolean: When true Editor's sketch widgets will be displayed */\r\n  @property() showSketchWidgets = false;\r\n\r\n  /** boolean: When true user can create multiple features */\r\n  @property() allowMultipleCreation = false;\r\n\r\n  /** boolean: When true clicking on a feature on the map will display a popup */\r\n  @property() popupEnabled = false;\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  State (internal)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** ICurrentPage: specifies the current page */\r\n  @state() _currentPage: ICurrentPage = 'templatePicker';\r\n\r\n  /** boolean: When true a loading indicator will be shown while the editor loads */\r\n  @state() _editorLoading = false;\r\n\r\n  /** boolean: When true reportOutsideAreaMessage will be shown at the top of form/editing page */\r\n  @state() _inValidGeomtryDrawn = false;\r\n\r\n  /**\r\n   * Contains the translations for this component.\r\n   * All UI strings should be defined here.\r\n   */\r\n  @state() _translations = useT9n<typeof T9nStrings>({ name: \"create-feature\", blocking: true });\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Properties (protected)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /**\r\n   * esri/widgets/Editor: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Editor.html\r\n   * The Editor constructor\r\n   */\r\n  protected Editor: typeof import('esri/widgets/Editor') | undefined;\r\n\r\n  /**\r\n   * esri/form/ExpressionInfo: https://developers.arcgis.com/javascript/latest/api-reference/esri-form-ExpressionInfo.html\r\n   * The ExpressionInfo constructor\r\n   */\r\n  protected ExpressionInfo: typeof import('esri/form/ExpressionInfo') | undefined;\r\n\r\n  /**\r\n   * https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html\r\n   * The Feature layer instance\r\n   */\r\n  protected FeatureLayer: typeof import('esri/layers/FeatureLayer') | undefined;\r\n\r\n  /**\r\n   * esri/form/elements/FieldElement: https://developers.arcgis.com/javascript/latest/api-reference/esri-form-elements-FieldElement.html\r\n   * The FieldElement constructor\r\n   */\r\n  protected FieldElement: typeof import('esri/form/elements/FieldElement') | undefined;\r\n\r\n  /** esri/form/FormTemplate: https://developers.arcgis.com/javascript/latest/api-reference/esri-form-FormTemplate.html */\r\n  protected FormTemplate: typeof import('esri/form/FormTemplate') | undefined;\r\n\r\n  /**\r\n   * esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html\r\n   * The MapView instance\r\n   */\r\n  protected MapView: typeof import('esri/views/MapView') | undefined;\r\n\r\n  /**\r\n   * esri/widgets/Home: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Home.html\r\n   * The Home instance\r\n   */\r\n  protected Home: typeof import('esri/widgets/Home') | undefined;\r\n\r\n  /**\r\n   * esri/widgets/Search: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Search.html\r\n   * The Search instance\r\n   */\r\n  protected Search: typeof import('esri/widgets/Search') | undefined;\r\n\r\n  /** boolean: Flag to maintain the add attachment */\r\n  protected _addingAttachment = false;\r\n\r\n  /** HTMLCalciteNoticeElement: calcite notice refrence element */\r\n  protected _calciteNotice = createRef<HTMLCalciteNoticeElement['el']>();\r\n\r\n  /** HTMLDivElement: The node the editor will be added to */\r\n  protected _container: HTMLDivElement | undefined;\r\n\r\n  /**__esri.Geometry: Stores the geometry object that has been drawn by the user. */\r\n  protected _drawnGeometry: __esri.Geometry | undefined;\r\n\r\n  /**\r\n   * esri/widgets/Editor: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Editor.html\r\n   * The Editor instance\r\n   */\r\n  protected _editor: __esri.Editor | undefined;\r\n\r\n  /** boolean: Flag to maintain form submission using submit button */\r\n  protected _isSubmitBtnClicked = false;\r\n\r\n  /** HTMLDivElement: The node for the map view */\r\n  protected _mapViewContainer = createRef<HTMLDivElement>();\r\n\r\n  /** esri/core/reactiveUtils: https://developers.arcgis.com/javascript/latest/api-reference/esri-core-reactiveUtils.html */\r\n  protected reactiveUtils: typeof import('esri/core/reactiveUtils') | undefined;\r\n\r\n  /**\r\n   * esri/widgets/Search: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Search.html\r\n   * The Search instance\r\n   */\r\n  protected _search: __esri.widgetsSearch | undefined;\r\n\r\n  /** HTMLDivElement: refrence for search div element */\r\n  protected _searchDiv = createRef<HTMLDivElement>();\r\n\r\n  /** __esri.FeatureLayer: selected feature layer; */\r\n  protected _selectedLayer: __esri.FeatureLayer | undefined;\r\n\r\n  /**\r\n   * esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html\r\n   * Updated map view instance\r\n   */\r\n  protected _updatedMapView: __esri.MapView | undefined;\r\n\r\n  /** HTMLCalciteAlertElement: Calcite alert element for guiding message */\r\n  protected _guidingMessageRefNode = createRef<HTMLDivElement>();\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Watch handlers\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Called each time the mapView prop is changed. */\r\n  private async mapViewWatchHandler(): Promise<void> {\r\n    this.mapView && await this.mapView.when(async () => {\r\n      await this.init();\r\n    });\r\n  }\r\n\r\n  /** Called each time when isMobile prop is changed. */\r\n  private async isMobileHandler(): Promise<void> {\r\n    // emit an event when mode is changed to back to the feature selection panel (to avoid multiple maps conflict)\r\n    this.modeChanged.emit();\r\n  }\r\n\r\n  /** When _editorLoading is true the container node will be hidden while starting the create workflow */\r\n  private async _editorLoadingWatchHandler(v: boolean): Promise<void> {\r\n    if (v) {\r\n      this._container?.classList.add('display-none');\r\n      if (this._selectedLayer?.isTable) {\r\n        if (this._selectedLayer.templates && this._editor) {\r\n          const template = this._selectedLayer.templates[0];\r\n          const creationInfo = {\r\n            layer: this._selectedLayer,\r\n            template,\r\n          };\r\n          await this._editor.startCreateFeaturesWorkflowAtFeatureCreation(creationInfo);\r\n          await this.hideEditorsElements();\r\n        }\r\n      } else {\r\n        await this.startCreate();\r\n      }\r\n      this._container?.classList.remove('display-none');\r\n      this._editorLoading = false;\r\n    }\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Methods (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /**\r\n   * Submit the created feature\r\n   *\r\n   * @returns Promise that resolves when the operation is complete\r\n   */\r\n  @method()\r\n  async submit(): Promise<void> {\r\n    if (this._editor?.viewModel?.featureFormViewModel) {\r\n      this._isSubmitBtnClicked = true;\r\n      this._editor.viewModel.featureFormViewModel.submit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Refreshes the editor state, optionally updating the floor level.\r\n   *\r\n   * @param floorLevel - (Optional) The floor level to set. If provided, the editor updates to this floor level.\r\n   * @returns A promise that resolves when the refresh operation is complete.\r\n   */\r\n  @method()\r\n  async refresh(floorLevel?: string): Promise<void> {\r\n    if (this._editor) {\r\n      // If a floor level is provided, the method updates the editor to the specified floor level.\r\n      if (floorLevel) {\r\n        await this._setFloorLevel(floorLevel);\r\n      } else {\r\n        // If reporting area and its layer exist, and the current page is not 'drawing',\r\n        // it queries for intersecting features.\r\n        // If the current page is not 'drawing' and no reporting area or layer exists, it emits a draw completion event with an invalid geometry flag.\r\n        if (this.reportingArea && this.reportingAreaLayer && this._currentPage !== 'drawing') {\r\n          await this.queryIntersectingFeatures();\r\n        } else if (this._currentPage !== 'drawing') {\r\n          this._inValidGeomtryDrawn = false;\r\n          this.drawComplete.emit(this._inValidGeomtryDrawn);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows feature form\r\n   */\r\n  @method()\r\n  async showForm(): Promise<void> {\r\n    this.progressStatus.emit(100);\r\n    this._container?.classList.remove('display-none');\r\n    this._mapViewContainer.value?.classList?.replace('show-map', 'hide-map');\r\n    this._currentPage = 'featureForm';\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Events (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Emitted on demand when the feature is created successfully */\r\n  success = createEvent();\r\n\r\n  /** Emitted on demand when the feature creation is failed */\r\n  fail = createEvent<Error>();\r\n\r\n  /** Emitted on demand when drawing is completed */\r\n  drawComplete = createEvent<boolean>();\r\n\r\n  /** Emitted on demand when in editing mode */\r\n  editingLocation = createEvent<void>();\r\n\r\n  /** Emitted on demand when editing attachments */\r\n  editingAttachment = createEvent<boolean>();\r\n\r\n  /** Emitted on demand when editor panel changes */\r\n  progressStatus = createEvent<number>();\r\n\r\n  /** Emitted on switched form mobile to desktop or vice versa */\r\n  modeChanged = createEvent();\r\n\r\n  /**\r\n   * Called once just after the component is first connected to the DOM.\r\n   *\r\n   * @returns Promise when complete\r\n   */\r\n  async load(): Promise<void> {\r\n    await this.initModules();\r\n  }\r\n\r\n  /** Called once just after the component is fully loaded and the first render() occurs.\r\n   * This lifecycle method is not expected to return a promise. The returned promise will be ignored by Lit rather than awaited. */\r\n  async loaded(): Promise<void> {\r\n    await this.init();\r\n  }\r\n\r\n  /**\r\n   * Called after each render\r\n   * Used to adjust the map top in case of mobile\r\n   */\r\n  override async updated(): Promise<void> {\r\n    // update the map top according to space occupied by notice msg and search\r\n    if (this.isMobile && this.updateMapPosition) {\r\n      // get the height of notice, search and add custom height 80px(editor msg) height to adjust the map top\r\n      const customHeight = this._currentPage === 'drawing' ? 80 : 30;\r\n      const searchDiv = this.enableSearch ? this._searchDiv.value?.offsetHeight : 0;\r\n      await this._calciteNotice.value?.componentOnReady();\r\n      const calciteNotice = this._calciteNotice.value?.offsetHeight || 0;\r\n      const top = calciteNotice + searchDiv + customHeight;\r\n      if (this._mapViewContainer.value) {\r\n        this._mapViewContainer.value.style.top = `${top}px`;\r\n      }\r\n    }\r\n    // adjust the margin of the guiding message to avoid extra spacing\r\n    if (this.reportingAreaMessage && this._guidingMessageRefNode.value?.children[0]) {\r\n      (this._guidingMessageRefNode.value.children[0] as HTMLElement).style.margin = '0px';\r\n    }\r\n  }\r\n\r\n  /** Invoked each time your component is added to the document's DOM. */\r\n  override disconnectedCallback(): void {\r\n    if (this._editor) {\r\n      // destroy the sketchViewmodel when create feature disconnect\r\n      if (this._editor.viewModel.sketchViewModel) {\r\n        this._editor.viewModel.sketchViewModel?.destroy();\r\n      }\r\n      this._editor.destroy();\r\n      // clear the grid from map if enabled from snapping tools\r\n      if (this.enableSnapping && this.mapView?.ui.view) {\r\n        (this.mapView?.ui.view as any).grid = null;\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Renders the component. */\r\n  override render(): JsxNode {\r\n    const showSearchWidget = this._currentPage === 'drawing' || this._currentPage === 'editing' ? '' : 'display-none';\r\n    const loaderClass = this._editorLoading ? '' : 'display-none';\r\n    const featureFormClass = this._editorLoading ? 'display-none' : '';\r\n    const mobileMapClass = this.isMobile && this.updateMapPosition ? 'show-map' : 'display-none';\r\n    const noticeKind = this._inValidGeomtryDrawn ? 'danger' : 'success';\r\n    const icon = this._inValidGeomtryDrawn ? 'exclamation-mark-triangle' : 'lightbulb';\r\n    const showGuidingMsg = this.showGuidingMsg && this._currentPage !== 'templatePicker';\r\n    let guidingMsg = this._translations.chooseCategoryMsg;\r\n    if (this._inValidGeomtryDrawn) {\r\n      guidingMsg = this.reportingAreaMessage || this._translations.reportOutsideAreaMessage;\r\n    } else if (this._currentPage === 'drawing' || this._currentPage === 'editing') {\r\n      guidingMsg = this._translations.provideLocationMsg;\r\n    } else if (this._currentPage === 'featureForm') {\r\n      guidingMsg = this._translations.provideDetailsMsg;\r\n    }\r\n\r\n    return (\r\n      <>\r\n        {showGuidingMsg && <calcite-notice\r\n          class=\"notice-msg\"\r\n          icon={icon}\r\n          kind={noticeKind}\r\n          open\r\n          ref={this._calciteNotice}>\r\n          <div\r\n            ref={this._guidingMessageRefNode}\r\n            slot=\"message\"\r\n            innerHTML={guidingMsg}\r\n          />\r\n        </calcite-notice>}\r\n        <calcite-loader class={loaderClass} label=\"\" scale=\"s\" />\r\n        {this._currentPage === 'featureForm' && this.isMobile &&\r\n          <calcite-button\r\n            appearance=\"transparent\"\r\n            class=\"edit-location-btn\"\r\n            iconStart=\"pin\"\r\n            onClick={this.editLocation}\r\n          >{this._translations.editLocationLabel}\r\n          </calcite-button>}\r\n        <div class={featureFormClass} id=\"feature-form\" />\r\n        {this.enableSearch && <div class={`search-widget ${showSearchWidget} ${featureFormClass}`} id=\"search-widget-ref\" ref={this._searchDiv} />}\r\n        <div class={mobileMapClass} ref={this._mapViewContainer} />\r\n      </>\r\n    );\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Functions (protected)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Init Editor widget and Search widget */\r\n  protected async init(): Promise<void> {\r\n    if (this.mapView && this.selectedLayerId) {\r\n      this._updatedMapView = this.mapView;\r\n      // In mobile mode show the map in panel\r\n      await (this.isMobile && this.updateMapPosition ? this.createMobileMapView() : this._loadWidgets());\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load esri javascript api modules\r\n   *\r\n   * @returns Promise resolving when function is done\r\n   * @protected\r\n   */\r\n  protected async initModules(): Promise<void> {\r\n    const [Editor, reactiveUtils, Search, ExpressionInfo, FieldElement, FormTemplate, MapView, Home] = await loadModules([\r\n      'esri/widgets/Editor',\r\n      'esri/core/reactiveUtils',\r\n      'esri/widgets/Search',\r\n      'esri/form/ExpressionInfo',\r\n      'esri/form/elements/FieldElement',\r\n      'esri/form/FormTemplate',\r\n      'esri/views/MapView',\r\n      'esri/widgets/Home'\r\n    ]);\r\n    this.Editor = Editor;\r\n    this.reactiveUtils = reactiveUtils;\r\n    this.Search = Search;\r\n    this.ExpressionInfo = ExpressionInfo;\r\n    this.FieldElement = FieldElement;\r\n    this.FormTemplate = FormTemplate;\r\n    this.MapView = MapView;\r\n    this.Home = Home;\r\n  }\r\n\r\n  /**\r\n   * updates the map view (in case of mobile)\r\n   *\r\n   * @protected\r\n   */\r\n  protected async createMobileMapView(): Promise<void> {\r\n    if (this._mapViewContainer.value && this.MapView && this.mapView) {\r\n      this._mapViewContainer.value.classList.add('hide-map');\r\n      await new this.MapView({\r\n        map: this.mapView.map as any,\r\n        container: this._mapViewContainer.value,\r\n        zoom: this.mapView.zoom,\r\n        center: this.mapView.center,\r\n        popupEnabled: this.popupEnabled\r\n      }).when(\r\n        (view: __esri.MapView) => {\r\n          // update the mapView and load all widgets\r\n          this._updatedMapView = view;\r\n          const home = this.Home && new this.Home({\r\n            view: this._updatedMapView\r\n          });\r\n          if (home) {\r\n            this._updatedMapView.ui.add(home, 'top-left');\r\n          }\r\n          void this._loadWidgets();\r\n        },\r\n        (e: any) => {\r\n          console.log(e);\r\n        },\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Loads the Editor and Search widgets\r\n   *\r\n   * @protected\r\n   */\r\n  protected async _loadWidgets(): Promise<void> {\r\n    await this.createEditorWidget();\r\n    if (this.enableSearch) {\r\n      await this.createSearchWidget();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Display editor widget to create the new feature\r\n   *\r\n   * @protected\r\n   */\r\n  protected async createEditorWidget(): Promise<void> {\r\n    if (this._editor) {\r\n      this._editor.destroy();\r\n    }\r\n    const layerInfos: any[] = [];\r\n    this._container = document.createElement('div');\r\n    this._container?.classList.add('display-none');\r\n\r\n    if (!this.enableSnapping) {\r\n      this._container.classList.add('hide-editor-toolbar');\r\n    }\r\n    const allMapLayers = this._updatedMapView && await getAllFeatureLayers(this._updatedMapView);\r\n    const selectedLayer = this.mapView && await getLayerOrTable(this.mapView, this.selectedLayerId);\r\n    if (selectedLayer) {\r\n      this._selectedLayer = selectedLayer;\r\n      // if layer is selected then only use the layerInfos while initializing the editor widget\r\n      if (!this._selectedLayer?.isTable && allMapLayers) {\r\n        // eslint-disable-next-line @typescript-eslint/no-misused-promises\r\n        allMapLayers.forEach((layer: __esri.FeatureLayer) => {\r\n          layerInfos.push({\r\n            layer,\r\n            enabled: layer?.type === 'feature' && layer?.id === this.selectedLayerId,\r\n            addEnabled: true, // default is true, set to false to disable the ability to add a new feature\r\n            updateEnabled: false, // if true, enable ability to edit an existing feature\r\n            deleteEnabled: false, // default is true, set to false to disable the ability to delete features\r\n          });\r\n        });\r\n      }\r\n    }\r\n\r\n    if (this.Editor) {\r\n      this._editor = new this.Editor({\r\n        view: this._updatedMapView,\r\n        layerInfos: layerInfos,\r\n        visibleElements: {\r\n          settingsMenu: this.enableSnapping,\r\n          snappingControls: this.enableSnapping,\r\n          createFeaturesSection: true,\r\n          editFeaturesSection: false,\r\n          flow: true,\r\n          sketch: this.showSketchWidgets && this._selectedLayer?.geometryType !== \"point\",\r\n        },\r\n        container: this._container,\r\n      });\r\n      if (this._mapViewContainer.value) {\r\n        this.el.insertBefore(this._container, this._mapViewContainer.value);\r\n      } else {\r\n        this.el.appendChild(this._container);\r\n      }\r\n\r\n      // If table is selected then directly start the create workflow\r\n      if (this._selectedLayer?.isTable) {\r\n        this._editorLoading = true;\r\n      }\r\n\r\n      if (this._editor) {\r\n        //Add handle to watch if attachments are added/edited\r\n        const attachmentHandle = this.reactiveUtils?.watch(\r\n          () => this._editor?.viewModel.state,\r\n          state => {\r\n            if (state === 'adding-attachment' || state === 'editing-attachment') {\r\n              this._addingAttachment = true;\r\n              this.editingAttachment.emit(true);\r\n            } else {\r\n              if (this._addingAttachment) {\r\n                this.editingAttachment.emit(false);\r\n                this._addingAttachment = false;\r\n              }\r\n            }\r\n          },\r\n        );\r\n        attachmentHandle && this._editor.viewModel.addHandles(attachmentHandle);\r\n\r\n        //Add handle to watch featureTemplatesViewModel ready state and then start the creation\r\n        const handle = this.reactiveUtils?.watch(\r\n          () => this._editor?.viewModel.featureTemplatesViewModel.state,\r\n          state => {\r\n            if (state === 'ready' && this._editor?.viewModel?.activeWorkflow?.type !== 'create-features') {\r\n              this.progressStatus.emit(50);\r\n              this._editorLoading = true;\r\n            }\r\n          },\r\n        );\r\n        handle && this._editor.viewModel.addHandles(handle);\r\n\r\n        //Add handle to watch featureFormViewModel ready state\r\n        const formHandle = this.reactiveUtils?.watch(\r\n          () => this._editor?.viewModel.featureFormViewModel?.state,\r\n          state => {\r\n            if (state === 'ready' && this._editor?.viewModel.featureFormViewModel && this._currentPage !== 'editing') {\r\n              this._mapViewContainer.value?.classList?.replace('show-map', 'hide-map');\r\n              this._editor.viewModel.featureFormViewModel.addHandles(\r\n                this._editor.viewModel.featureFormViewModel.on('submit', this.submitted.bind(this))\r\n              );\r\n              setTimeout(() => {\r\n                void this._setFloorLevel(this.floorLevel);\r\n              }, 50);\r\n              if (!this.allowMultipleCreation && this._editor.activeWorkflow) {\r\n                (this._editor.activeWorkflow.data as any).creationInfo.maxFeatures = 1;\r\n              }\r\n              this._currentPage = 'featureForm';\r\n              this.progressStatus.emit(100);\r\n              this.drawComplete.emit(false);\r\n            }\r\n          },\r\n        );\r\n        formHandle && this._editor.viewModel.addHandles(formHandle);\r\n\r\n        //Add handle to watch editor viewmodel state and then show the search widget\r\n        const createFeatureHandle = this.reactiveUtils?.watch(\r\n          () => this._editor?.viewModel.state,\r\n          state => {\r\n            if (state === 'creating-features' && this._editor?.viewModel.featureFormViewModel) {\r\n              if (this._editor.viewModel.featureFormViewModel.state === 'disabled') {\r\n                this._mapViewContainer.value?.classList?.replace('hide-map', 'show-map');\r\n                if (this._selectedLayer && !this._selectedLayer.isTable) {\r\n                  this._currentPage = 'drawing';\r\n                }\r\n              }\r\n            }\r\n          },\r\n        );\r\n        createFeatureHandle && this._editor.viewModel.addHandles(createFeatureHandle);\r\n\r\n        // eslint-disable-next-line @typescript-eslint/no-misused-promises\r\n        this._editor.on('sketch-create', async (e) => {\r\n          if (e.detail.state === 'complete') {\r\n            this._drawnGeometry = e.detail.graphic.geometry as __esri.Geometry;\r\n            if (this.reportingArea && this.reportingAreaLayer) {\r\n              await this.queryIntersectingFeatures();\r\n            }\r\n          }\r\n        });\r\n        let debounceTimer: number\r\n        this._editor.on('sketch-update', (e) => {\r\n          clearTimeout(debounceTimer)\r\n          // eslint-disable-next-line @typescript-eslint/no-misused-promises\r\n          debounceTimer = window.setTimeout(async () => {\r\n            this._drawnGeometry = e.detail.graphics[0].geometry as __esri.Geometry;\r\n            if (this.reportingArea && this.reportingAreaLayer) {\r\n              await this.queryIntersectingFeatures();\r\n            }\r\n          }, 50);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Queries the map for features that intersect with a drawn geometry and emits the result.\r\n   */\r\n  protected async queryIntersectingFeatures(): Promise<void> {\r\n    const polygonLayer = this.mapView && await getLayerOrTable(this.mapView, this.reportingAreaLayer!);\r\n    if (polygonLayer) {\r\n      const query = polygonLayer.createQuery() as __esri.QueryProperties;\r\n      query.geometry = this._drawnGeometry;\r\n      query.spatialRelationship = 'intersects';\r\n      const intersectingCount = await polygonLayer.queryFeatureCount(query);\r\n      const nonValidGeomtryDrawn = intersectingCount === 0;\r\n      this._inValidGeomtryDrawn = nonValidGeomtryDrawn;\r\n      this.drawComplete.emit(this._inValidGeomtryDrawn);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Shows map for edititng the location\r\n   */\r\n  protected editLocation(): void {\r\n    this.progressStatus.emit(75);\r\n    this.editingLocation.emit();\r\n    this._container?.classList.add('display-none');\r\n    this._mapViewContainer.value?.classList.replace('hide-map', 'show-map');\r\n    this._currentPage = 'editing';\r\n  }\r\n\r\n  /**\r\n   * Start creating the feature\r\n   *\r\n   * @protected\r\n   */\r\n  protected async startCreate(): Promise<void> {\r\n    // hides the header elements on template picker page\r\n    await this.hideEditorsElements();\r\n    return new Promise<any>((resolve, reject) => {\r\n      if (this._editor?.viewModel.featureTemplatesViewModel.items?.length) {\r\n        const items: __esri.TemplateItem[] = (this._editor.viewModel.featureTemplatesViewModel.items[0] as any).items;\r\n        //once the feature template is selected handle the event for formSubmit and sketch complete\r\n        //also, hide the headers and footer in the editor as we will be showing our own submit and cancel button\r\n        this._editor.viewModel.featureTemplatesViewModel.addHandles(\r\n          this._editor.viewModel.featureTemplatesViewModel.on('select', () => {\r\n            this.progressStatus.emit(75);\r\n            setTimeout(() => {\r\n              //hides the header and footer elements in editor widget\r\n              this.hideEditorsElements().then(\r\n                () => {\r\n                  resolve({});\r\n                },\r\n                e => reject(e),\r\n              );\r\n            }, 700);\r\n          }));\r\n        //if only one feature template then directly start geometry creation for that\r\n        if (items.length === 1) {\r\n          this._editor.viewModel.featureTemplatesViewModel.select(items[0]);\r\n        }\r\n        const resolvePromise = items.length > 1;\r\n        this.hideEditorsElements().then(\r\n          () => {\r\n            if (resolvePromise) {\r\n              resolve({});\r\n            }\r\n          },\r\n          e => resolvePromise && reject(e),\r\n        );\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Display search widget to search location\r\n   *\r\n   * @protected\r\n   */\r\n  protected async createSearchWidget(): Promise<void> {\r\n    if (this._updatedMapView && this.Search) {\r\n      let searchOptions: __esri.widgetsSearchProperties = {\r\n        view: this._updatedMapView,\r\n      };\r\n      if (this.searchConfiguration) {\r\n        const searchConfiguration = this._getSearchConfig(this.searchConfiguration, this._updatedMapView);\r\n        searchOptions = {\r\n          ...searchConfiguration,\r\n        };\r\n      }\r\n      this._search = new this.Search(searchOptions);\r\n      this._search.container = 'search-widget-ref';\r\n      this._search.popupEnabled = false;\r\n      this._search.resultGraphicEnabled = false;\r\n\r\n      let pointGeometry: any = undefined;\r\n      // on search get the geometry of the searched location and pass it in sketchViewModel and go to featureForm page\r\n      this._search.viewModel.addHandles(\r\n        this._search.on('search-complete', e => {\r\n          void this._updatedMapView?.goTo(e.results[0].results[0].extent);\r\n          if (this._selectedLayer?.geometryType === 'point') {\r\n            pointGeometry = e.results[0].results[0]?.feature.geometry;\r\n          }\r\n        }));\r\n\r\n      //Add handle to watch if search viewModel state is ready\r\n      const createFeatureHandle = this.reactiveUtils?.watch(\r\n        () => this._search?.viewModel.state,\r\n        state => {\r\n          if (state === 'ready') {\r\n            setTimeout(() => {\r\n              if (this._editor?.viewModel.sketchViewModel?.createGraphic && pointGeometry) {\r\n                this._editor.viewModel.sketchViewModel.createGraphic.set('geometry', pointGeometry);\r\n                this._editor.viewModel.sketchViewModel.complete();\r\n                void this.hideEditorsElements();\r\n              } else if (this._editor?.viewModel.sketchViewModel && this._editor.viewModel.sketchViewModel.updateGraphics.length > 0 && pointGeometry) {\r\n                const graphic = this._editor?.viewModel.sketchViewModel?.updateGraphics.getItemAt(0);\r\n                if (graphic) {\r\n                  graphic.set('geometry', pointGeometry);\r\n                  void this._editor?.viewModel.sketchViewModel?.update(graphic);\r\n                  void this.hideEditorsElements();\r\n                }\r\n              }\r\n            }, 100);\r\n          }\r\n        },\r\n      );\r\n      createFeatureHandle && this._search.viewModel.addHandles(createFeatureHandle);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Initialize the search widget based on user defined configuration\r\n   *\r\n   * @param searchConfiguration search configuration defined by the user\r\n   * @param view the current map view\r\n   * @protected\r\n   */\r\n  protected _getSearchConfig(searchConfiguration: ISearchConfiguration, view: __esri.MapView): ISearchConfiguration {\r\n    const INCLUDE_DEFAULT_SOURCES = 'includeDefaultSources';\r\n    const sources = searchConfiguration.sources;\r\n\r\n    if (sources && sources?.length > 0) {\r\n      searchConfiguration[INCLUDE_DEFAULT_SOURCES] = false;\r\n\r\n      sources.forEach(source => {\r\n        const isLayerSource = source.hasOwnProperty('layer');\r\n        if (isLayerSource) {\r\n          const layerSource = source as any;\r\n          //const layerSource = source as ILayerSourceConfigItem;\r\n          const layerId = layerSource.layer?.id;\r\n          const layerFromMap = layerId ? view.map?.findLayerById(layerId) : '';\r\n          const layerUrl = layerSource?.layer?.url;\r\n          if (layerFromMap) {\r\n            layerSource.layer = layerFromMap as __esri.FeatureLayer;\r\n          } else if (layerUrl && this.FeatureLayer) {\r\n            layerSource.layer = new this.FeatureLayer(layerUrl as any) as __esri.FeatureLayer;\r\n          }\r\n        }\r\n      });\r\n\r\n      sources?.forEach(source => {\r\n        const isLocatorSource = source.hasOwnProperty('locator');\r\n        if (isLocatorSource) {\r\n          const locatorSource = source as ILocatorSourceConfigItem;\r\n          if (locatorSource?.name === 'ArcGIS World Geocoding Service') {\r\n            const outFields = locatorSource.outFields || ['Addr_type', 'Match_addr', 'StAddr', 'City'];\r\n            locatorSource.outFields = outFields;\r\n            locatorSource.singleLineFieldName = 'SingleLine';\r\n          }\r\n\r\n          locatorSource.url = locatorSource.url;\r\n          delete locatorSource.url;\r\n        }\r\n      });\r\n    } else {\r\n      searchConfiguration = {\r\n        ...searchConfiguration,\r\n        includeDefaultSources: true,\r\n      };\r\n    }\r\n    return searchConfiguration;\r\n  }\r\n\r\n  /**\r\n   * Add the floor level value to form\r\n   *\r\n   * @param level selected floor level\r\n   * @protected\r\n   */\r\n  protected async _setFloorLevel(level: string): Promise<void> {\r\n    if (!level) {\r\n      return;\r\n    }\r\n    const layer = this._selectedLayer;\r\n    const floorField = layer?.floorInfo?.floorField;\r\n    if (floorField) {\r\n      const layerField = layer.fields.find(field => field.name === floorField);\r\n      // if layer field is present and form template is not present only then we can set value of floorfield into feature form otherwise create a mannual formtemplate to add the floorfeild element\r\n      if (layerField && !layer?.formTemplate) {\r\n        if (this._editor?.viewModel.featureFormViewModel) {\r\n          this._editor.viewModel.featureFormViewModel.setValue(layerField.name, level);\r\n          layerField.editable = false;\r\n        }\r\n      } else if (layer.formTemplate && this.formElements && this.ExpressionInfo && this.FieldElement) {\r\n        const floorInfoExpression = new this.ExpressionInfo({\r\n          expression: `'${level}'`,\r\n          name: 'floor-info-test',\r\n          title: 'Floor Info',\r\n          returnType: 'string',\r\n        });\r\n        const levelIdFieldElement = new this.FieldElement({\r\n          label: floorField,\r\n          editableExpression: 'false',\r\n          fieldName: floorField,\r\n          input: {\r\n            type: 'text-box',\r\n            maxLength: 50,\r\n            minLength: 0,\r\n          },\r\n          valueExpression: floorInfoExpression.name,\r\n        });\r\n        this._updatedMapView?.map!.editableLayers.forEach((layer) => {\r\n          const orgElements = this.formElements.orgElements;\r\n          const orgExpressionInfos = this.formElements.orgExpressionInfos;\r\n          const elements = [...orgElements];\r\n          elements.push(levelIdFieldElement);\r\n          if (layer.type === 'feature' && this.FormTemplate) {\r\n            const featureLayer: __esri.FeatureLayer = layer as __esri.FeatureLayer;\r\n            // Creating formtemplate\r\n            const floorInfoTemplate = new this.FormTemplate({\r\n              title: featureLayer?.formTemplate?.title,\r\n              description: featureLayer?.formTemplate?.description,\r\n              elements,\r\n              expressionInfos: [floorInfoExpression].concat(orgExpressionInfos),\r\n            });\r\n            layer.formTemplate = floorInfoTemplate;\r\n          }\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Hides the elements of editor widget\r\n   *\r\n   * @protected\r\n   */\r\n  protected async hideEditorsElements(): Promise<void> {\r\n    if (!this.customizeSubmit) {\r\n      return;\r\n    }\r\n    await this.timeout(700);\r\n    //hides the header and footer on the featureForm\r\n    this.el\r\n      .querySelector('.esri-editor')\r\n      ?.querySelectorAll('calcite-flow-item')\r\n      ?.forEach(flowItem => {\r\n        const article = flowItem.shadowRoot?.querySelector('calcite-panel')?.shadowRoot?.querySelector('article');\r\n        //hide the header\r\n        article?.querySelector('header')?.setAttribute('style', 'display: none');\r\n        //hide the footer\r\n        article?.querySelector('footer')?.setAttribute('style', 'display: none');\r\n      });\r\n  }\r\n\r\n  /**\r\n   * On creation of feature emit the event that the feature is created\r\n   *\r\n   * @param _evt feature submit event\r\n   * @protected\r\n   */\r\n  protected async submitted(_evt: any): Promise<void> {\r\n    //return if any attribute is invalid , focus will be shifted to the invalid attribute in feature form\r\n    if (_evt.invalid.length) {\r\n      this._isSubmitBtnClicked = false;\r\n      return;\r\n    }\r\n    //emit success or fail based on the result\r\n    if (this._isSubmitBtnClicked) {\r\n      this._isSubmitBtnClicked = false;\r\n      try {\r\n        if (this._editor?.activeWorkflow) {\r\n          await this._editor.activeWorkflow.commit();\r\n          //throw errors if any failures\r\n          if (this._editor.viewModel.failures?.length) {\r\n            this._editor.viewModel.failures.some(failure => {\r\n              if (failure.error) {\r\n                throw failure.error;\r\n              }\r\n            });\r\n          }\r\n        }\r\n      } catch (e: any) {\r\n        this.fail.emit(e);\r\n        return;\r\n      }\r\n      this.success.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * call setTimeout in Promise wrapper\r\n   *\r\n   * @param delay The time, in milliseconds that the timer should wait before the promise is resolved\r\n   * @protected\r\n   */\r\n  protected async timeout(delay: number): Promise<void> {\r\n    return new Promise(resolve => setTimeout(resolve, delay));\r\n  }\r\n}\r\n"],"names":["CreateFeature","LitElement","useT9n","createRef","createEvent","styles","noShadowRoot","changes","v","template","creationInfo","floorLevel","customHeight","searchDiv","top","showSearchWidget","loaderClass","featureFormClass","mobileMapClass","noticeKind","icon","showGuidingMsg","guidingMsg","html","ref$jsx","safeClassMap","Editor","reactiveUtils","Search","ExpressionInfo","FieldElement","FormTemplate","MapView","Home","loadModules","view","home","layerInfos","allMapLayers","getAllFeatureLayers","selectedLayer","getLayerOrTable","layer","attachmentHandle","state","handle","formHandle","createFeatureHandle","e","debounceTimer","polygonLayer","query","nonValidGeomtryDrawn","resolve","reject","items","resolvePromise","searchOptions","pointGeometry","graphic","searchConfiguration","INCLUDE_DEFAULT_SOURCES","sources","source","layerSource","layerId","layerFromMap","layerUrl","locatorSource","outFields","level","floorField","layerField","field","floorInfoExpression","levelIdFieldElement","orgElements","orgExpressionInfos","elements","featureLayer","floorInfoTemplate","flowItem","article","_evt","failure","delay"],"mappings":"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"}

package/dist/components/create-related-feature/customElement.d.ts

@@ -4,15 +4,39 @@ import { PropertyValues } from 'lit';
 import { PublicLitElement as LitElement, TargetedEvent, JsxNode } from '@arcgis/lumina';
 
 export declare class CreateRelatedFeature extends LitElement {
+    /**
+     * boolean: Set this to true when have a custom submit button in the app.
+     * This will hide the header and footer elements of the editor and user needs to execute the submit method manually.
+     *
+     * @default false
+     */
     customizeSubmit?: boolean;
+    /**
+     * When true the snapping options will be exposed
+     *
+     * @default false
+     */
     enableSnapping: boolean;
+    /** esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */
     mapView: __esri.MapView | undefined;
+    /** __esri.Graphic: https://developers.arcgis.com/javascript/latest/api-reference/esri-Graphic.html */
     selectedFeature: __esri.Graphic | undefined;
+    /**
+     * boolean: When true the notice message should be shown
+     *
+     * @default true
+     */
     showGuidingMsg?: boolean;
+    /** __esri.FeatureLayer: https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html */
     table: __esri.FeatureLayer | undefined;
+    /** Submit the comment */
     submit(): Promise<void>;
+    /** Emitted on demand when the comment is submitted successfully */
     readonly success: TargetedEvent<this, void>;
+    /** Emitted on demand when the comment submission is failed */
     readonly fail: TargetedEvent<this, Error>;
+    /** Emitted on demand when any action is pending or completed */
     readonly isActionPending: TargetedEvent<this, boolean>;
+    /** Emitted on demand when form is ready */
     readonly formReady: TargetedEvent<this, void>;
 }

package/dist/components/create-related-feature/customElement.js

@@ -5,7 +5,7 @@ import { css as p, html as l } from "lit";
 import { LitElement as f, createEvent as d, noShadowRoot as w, safeClassMap as y } from "@arcgis/lumina";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/1.1/esri/copyright.txt for details.
-v1.1.0-next.20250917.1 */
+v1.1.0-next.20250917.3 */
 const b = p`@layer{/**
  * @license
  * Copyright 2025 Esri
@@ -155,4 +155,3 @@ h("create-related-feature", g);
 export {
   g as CreateRelatedFeature
 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"customElement.js","sources":["../../../src/components/create-related-feature/create-related-feature.tsx"],"sourcesContent":["/**\r\n * @license\r\n * Copyright 2025 Esri\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *    http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\nimport type T9nStrings from './assets/t9n/messages.en.json';\r\nimport { loadModules } from '../../utils/loadModules';\r\nimport { useT9n } from '../../controllers/useT9n';\r\nimport type { PropertyValues } from 'lit';\r\nimport {\r\n  LitElement,\r\n  property,\r\n  createEvent,\r\n  Fragment,\r\n  h,\r\n  method,\r\n  noShadowRoot,\r\n  state,\r\n} from '@arcgis/lumina';\r\nimport type {\r\n  JsxNode,\r\n} from '@arcgis/lumina';\r\nimport { styles } from './create-related-feature.css';\r\n\r\ndeclare global {\r\n  interface DeclareElements {\r\n    'create-related-feature': CreateRelatedFeature;\r\n  }\r\n}\r\n\r\nexport class CreateRelatedFeature extends LitElement {\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Overrides (internal)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  static override styles = styles;\r\n\r\n  static override shadowRootOptions = noShadowRoot;\r\n\r\n  /** TODO: [MIGRATION] Consider inlining some of the watch functions called inside of this method to reduce boilerplate code */\r\n  override willUpdate(changes: PropertyValues<this>): void {\r\n    /* TODO: [MIGRATION] First time Lit calls willUpdate(), changes will include not just properties provided by the user, but also any default values your component set.\r\n    To account for this semantics change, the checks for (this.hasUpdated || value != defaultValue) was added in this method\r\n    Please refactor your code to reduce the need for this check.\r\n    Docs: https://qawebgis.esri.com/components/lumina/transition-from-stencil#watching-for-property-changes */\r\n\r\n    if (changes.has('mapView')) {\r\n      void this.mapViewWatchHandler();\r\n    }\r\n\r\n    if (changes.has('_editorLoading') && (this.hasUpdated || this._editorLoading !== false)) {\r\n      void this._editorLoadingWatchHandler(this._editorLoading);\r\n    }\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Properties (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /**\r\n   * boolean: Set this to true when have a custom submit button in the app.\r\n   * This will hide the header and footer elements of the editor and user needs to execute the submit method manually.\r\n   */\r\n  @property() customizeSubmit?: boolean = false;\r\n\r\n  /** When true the snapping options will be exposed */\r\n  @property() enableSnapping = false;\r\n\r\n  /** esri/views/MapView: https://developers.arcgis.com/javascript/latest/api-reference/esri-views-MapView.html */\r\n  @property() mapView: __esri.MapView | undefined;\r\n\r\n  /** __esri.Graphic: https://developers.arcgis.com/javascript/latest/api-reference/esri-Graphic.html */\r\n  @property() selectedFeature: __esri.Graphic | undefined;\r\n\r\n  /** boolean: When true the notice message should be shown */\r\n  @property() showGuidingMsg?: boolean = true;\r\n\r\n  /** __esri.FeatureLayer: https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-FeatureLayer.html */\r\n  @property() table: __esri.FeatureLayer | undefined;\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  State (internal)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** boolean: When true a loading indicator will be shown while the editor loads */\r\n  @state() _editorLoading = false;\r\n\r\n  /**\r\n   * Contains the translations for this component.\r\n   * All UI strings should be defined here.\r\n   */\r\n  @state() _translations = useT9n<typeof T9nStrings>({name: \"create-related-feature\", blocking: true});\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Properties (protected)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /**\r\n   * esri/widgets/Editor: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Editor.html\r\n   * The Editor constructor\r\n   */\r\n  protected Editor: typeof import('esri/widgets/Editor') | undefined;\r\n\r\n  /** esri/core/reactiveUtils: https://developers.arcgis.com/javascript/latest/api-reference/esri-core-reactiveUtils.html */\r\n  protected reactiveUtils: typeof import('esri/core/reactiveUtils') | undefined;\r\n\r\n  /** boolean: Flag to maintain the add attachment */\r\n  protected _addingAttachment = false;\r\n\r\n  /** HTMLDivElement: The node the editor will be added to */\r\n  protected _container: HTMLDivElement | undefined;\r\n\r\n  /**\r\n   * esri/widgets/Editor: https://developers.arcgis.com/javascript/latest/api-reference/esri-widgets-Editor.html\r\n   * The Editor instance\r\n   */\r\n  protected _editor: __esri.Editor | undefined;\r\n\r\n  /** boolean: Flag to maintain form submission using submit button */\r\n  protected _isSubmitBtnClicked = false;\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Watch handlers\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Called each time the mapView prop is changed. */\r\n  private async mapViewWatchHandler(): Promise<void> {\r\n    await this.mapView?.when(async () => {\r\n      await this.init();\r\n    });\r\n  }\r\n\r\n  /** When _editorLoading is true the container node will be hidden while starting the create workflow */\r\n  private async _editorLoadingWatchHandler(v: boolean): Promise<void> {\r\n    if (v) {\r\n      this._container?.classList.add('display-none');\r\n      await this.startCreate();\r\n      this._container?.classList.remove('display-none');\r\n      this._editorLoading = false;\r\n    }\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Methods (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Submit the comment */\r\n  @method()\r\n  async submit(): Promise<void> {\r\n    if (this._editor?.viewModel?.featureFormViewModel) {\r\n      this._isSubmitBtnClicked = true;\r\n      this._editor.viewModel.featureFormViewModel.submit();\r\n    }\r\n  }\r\n\r\n  //--------------------------------------------------------------------------\r\n  //\r\n  //  Events (public)\r\n  //\r\n  //--------------------------------------------------------------------------\r\n\r\n  /** Emitted on demand when the comment is submitted successfully */\r\n  success = createEvent();\r\n\r\n  /** Emitted on demand when the comment submission is failed */\r\n  fail = createEvent<Error>();\r\n\r\n  /** Emitted on demand when any action is pending or completed */\r\n  isActionPending = createEvent<boolean>();\r\n\r\n  /** Emitted on demand when form is ready */\r\n  formReady = createEvent();\r\n\r\n  /**\r\n   * Called once just after the component is first connected to the DOM.\r\n   *\r\n   * @returns Promise when complete\r\n   */\r\n  async load(): Promise<void> {\r\n    await this.initModules();\r\n  }\r\n\r\n  /** Init Editor widget and starts the create workflow */\r\n  protected async init(): Promise<void> {\r\n    if (this.mapView) {\r\n      await this.createEditorWidget();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load esri javascript api modules\r\n   *\r\n   * @returns Promise resolving when function is done\r\n   * @protected\r\n   */\r\n  protected async initModules(): Promise<void> {\r\n    const [Editor, reactiveUtils] = await loadModules(['esri/widgets/Editor', 'esri/core/reactiveUtils']);\r\n    this.Editor = Editor;\r\n    this.reactiveUtils = reactiveUtils;\r\n  }\r\n\r\n  override render(): JsxNode {\r\n    const loaderClass = this._editorLoading ? '' : 'display-none';\r\n    return (\r\n      <>\r\n        {this.showGuidingMsg && (\r\n          <calcite-notice class=\"notice-msg\" icon=\"lightbulb\" kind=\"success\" open>\r\n            <div slot=\"message\">{this._translations.provideDetailsMsg}</div>\r\n          </calcite-notice>\r\n        )}\r\n        <calcite-loader class={loaderClass} label=\"\" scale=\"s\" />\r\n      </>\r\n    );\r\n  }\r\n\r\n  /** Called once just after the component is fully loaded and the first render() occurs. */\r\n  loaded(): void {\r\n    void this.init();\r\n  }\r\n\r\n  /** Invoked each time your component is added to the document's DOM. */\r\n  override disconnectedCallback(): void {\r\n    if (this._editor) {\r\n      this._editor.destroy();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Display editor widget to create the new feature\r\n   *\r\n   * @protected\r\n   */\r\n  protected async createEditorWidget(): Promise<void> {\r\n    if (this._editor) {\r\n      this._editor.destroy();\r\n    }\r\n    this._container = document.createElement('div');\r\n    this._container?.classList.add('display-none');\r\n\r\n    if (!this.enableSnapping) {\r\n      this._container.classList.add('hide-editor-toolbar');\r\n    }\r\n\r\n    if (this.Editor) {\r\n      this._editor = new this.Editor({\r\n        view: this.mapView,\r\n        visibleElements: {\r\n          flow: true,\r\n          settingsMenu: this.enableSnapping,\r\n          sketch: false,\r\n          snappingControls: this.enableSnapping,\r\n        } as any,\r\n        container: this._container,\r\n      });\r\n      this.el.appendChild(this._container);\r\n\r\n      if (this.reactiveUtils) {\r\n        //Add handle to watch featureTemplatesViewModel ready state and then start the creation\r\n        const handle = this.reactiveUtils.watch(\r\n          () => this._editor?.viewModel.featureTemplatesViewModel.state,\r\n          state => {\r\n            if (state === 'ready') {\r\n              this._editorLoading = true;\r\n            }\r\n          },\r\n        );\r\n        this._editor.viewModel.addHandles(handle);\r\n\r\n        // Add handle to watch if attachments are added/edited\r\n        const attachmentHandle = this.reactiveUtils.watch(\r\n          () => this._editor?.viewModel.state,\r\n          state => {\r\n            if (state === 'adding-attachment' || state === 'editing-attachment') {\r\n              this._addingAttachment = true;\r\n              this.isActionPending.emit(true);\r\n            } else {\r\n              if (this._addingAttachment) {\r\n                this.isActionPending.emit(false);\r\n                this._addingAttachment = false;\r\n              }\r\n            }\r\n          },\r\n        );\r\n        this._editor.viewModel.addHandles(attachmentHandle);\r\n\r\n        //Add handle to watch featureFormViewModel ready state\r\n        const formHandle = this.reactiveUtils.watch(\r\n          () => this._editor?.viewModel.featureFormViewModel?.state,\r\n          state => {\r\n            if (state === 'ready') {\r\n              this.formReady.emit();\r\n            }\r\n          },\r\n        );\r\n        this._editor.viewModel.addHandles(formHandle);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Start creating the feature feature form\r\n   *\r\n   * @protected\r\n   */\r\n  protected async startCreate(): Promise<void> {\r\n    const parentLayer = this.selectedFeature?.layer as __esri.FeatureLayer;\r\n    const childTable = this.table;\r\n    if (parentLayer?.relationships &&\r\n      childTable?.relationships &&\r\n      this.selectedFeature &&\r\n      childTable.templates\r\n    ) {\r\n      const parentRelationship = parentLayer.relationships[0];\r\n      const childRelationship = childTable.relationships.find(rel => parentLayer.layerId === rel.relatedTableId);\r\n      const oid = Number(this.selectedFeature.getObjectId());\r\n      if (!Number.isNaN(oid) && childRelationship) {\r\n        const queryResult = await parentLayer.queryFeatures({\r\n          objectIds: [oid],\r\n          outFields: [parentLayer.objectIdField, parentRelationship.keyField],\r\n        });\r\n        const parentFeature = queryResult.features[0];\r\n        const template = childTable.templates[0];\r\n        const attributeOverrides = this.makeAttributesForRelatedFeature(parentFeature, parentRelationship, childRelationship);\r\n        const creationInfo = {\r\n          attributeOverrides,\r\n          layer: childTable,\r\n          template,\r\n        };\r\n        await this._editor?.startCreateFeaturesWorkflowAtFeatureCreation(creationInfo);\r\n        //hides the header and footer elements in editor widget\r\n        await this.hideEditorsElements();\r\n        this._editor?.viewModel?.featureFormViewModel?.addHandles(\r\n          this._editor.viewModel.featureFormViewModel.on('submit', this.submitted.bind(this))\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Hides the elements of editor widget\r\n   *\r\n   * @protected\r\n   */\r\n  protected async hideEditorsElements(): Promise<void> {\r\n    if (!this.customizeSubmit) {\r\n      return;\r\n    }\r\n    await this.timeout(700);\r\n    //hides the header and footer on the featureForm\r\n    this.el\r\n      .querySelector('.esri-editor')\r\n      ?.querySelectorAll('calcite-flow-item')\r\n      ?.forEach(flowItem => {\r\n        const article = flowItem.shadowRoot?.querySelector('calcite-panel')?.shadowRoot?.querySelector('article');\r\n        //hide the header\r\n        article?.querySelector('header')?.setAttribute('style', 'display: none');\r\n        //hide the footer\r\n        article?.querySelector('footer')?.setAttribute('style', 'display: none');\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Makes attributes for related feature\r\n   *\r\n   * @param parentFeature Parent feature\r\n   * @param parentRelationship Parent relationship\r\n   * @param childRelationship Child relationship\r\n   * @returns Attributes for related feature\r\n   * @protected\r\n   */\r\n  protected makeAttributesForRelatedFeature(\r\n    parentFeature: __esri.Graphic,\r\n    parentRelationship: __esri.Relationship,\r\n    childRelationship: __esri.Relationship\r\n  ): any {\r\n    const parentKeyField = parentRelationship.keyField;\r\n    let parentKeyValue;\r\n    if (parentFeature.attributes.hasOwnProperty(parentKeyField)) {\r\n      parentKeyValue = parentFeature.getAttribute(parentKeyField);\r\n    } else if (parentFeature.attributes.hasOwnProperty(parentKeyField.toLowerCase())) {\r\n      parentKeyValue = parentFeature.getAttribute(parentKeyField.toLowerCase());\r\n    } else if (parentFeature.attributes.hasOwnProperty(parentKeyField.toUpperCase())) {\r\n      parentKeyValue = parentFeature.getAttribute(parentKeyField.toUpperCase());\r\n    }\r\n    let childKeyField = childRelationship.keyField;\r\n    // get the field from table which name is same as childKeyField and use that field name as childKeyField\r\n    const field = this.table?.fields.find(field => field.name.toLocaleLowerCase() === childKeyField.toLocaleLowerCase());\r\n    if (field) {\r\n      childKeyField = field.name;\r\n      const childAttributes = {\r\n        [childKeyField]: parentKeyValue,\r\n      };\r\n      return childAttributes;\r\n    } else {\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * On creation of feature emit the event that the feature is created\r\n   *\r\n   * @param _evt feature submit event\r\n   * @protected\r\n   */\r\n  protected async submitted(_evt: any): Promise<void> {\r\n    //return if any attribute is invalid , focus will be shifted to the invalid attribute in feature form\r\n    if (_evt.invalid.length) {\r\n      this._isSubmitBtnClicked = false;\r\n      return;\r\n    }\r\n    //Submit only when valid attributes\r\n    //emit success or fail based on the result\r\n    if (_evt.valid.length && this._isSubmitBtnClicked) {\r\n      this._isSubmitBtnClicked = false;\r\n      try {\r\n        if (this._editor?.activeWorkflow) {\r\n          await this._editor.activeWorkflow.commit();\r\n          //throw errors if any failures\r\n          if (this._editor.viewModel.failures?.length) {\r\n            this._editor.viewModel.failures.some(failure => {\r\n              if (failure.error) {\r\n                throw failure.error;\r\n              }\r\n            });\r\n          }\r\n        }\r\n      } catch (e: any) {\r\n        this.fail.emit(e);\r\n        return;\r\n      }\r\n      this.success.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * call setTimeout in Promise wrapper\r\n   *\r\n   * @param delay The time, in milliseconds that the timer should wait before the promise is resolved\r\n   * @protected\r\n   */\r\n  protected async timeout(delay: number): Promise<void> {\r\n    return new Promise(resolve => setTimeout(resolve, delay));\r\n  }\r\n}\r\n"],"names":["CreateRelatedFeature","LitElement","useT9n","createEvent","styles","noShadowRoot","changes","v","Editor","reactiveUtils","loadModules","loaderClass","html","safeClassMap","handle","state","attachmentHandle","formHandle","parentLayer","childTable","parentRelationship","childRelationship","rel","oid","parentFeature","template","creationInfo","flowItem","article","parentKeyField","parentKeyValue","childKeyField","field","_evt","failure","e","delay","resolve"],"mappings":"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"}