@arcgis/map-components 1.0.0-beta.17 → 1.0.0-beta.19

package/dist/components/arcgis-time-slider.js

@@ -0,0 +1,256 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { _ as newWidgetsTimeSlider, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, o as onDisconnectedHelper } from './disconnected.js';
+import { d as defineCustomElement$2 } from './arcgis-expand2.js';
+
+const arcgisTimeSliderCss = "arcgis-time-slider{}";
+
+const ArcgisTimeSlider$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.triggerAction = createEvent(this, "triggerAction", 7);
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.actions = undefined;
+    this.effectiveStops = undefined;
+    this.fullTimeExtent = undefined;
+    this.layout = undefined;
+    this.loop = undefined;
+    this.mode = undefined;
+    this.playRate = undefined;
+    this.stops = undefined;
+    this.tickConfigs = undefined;
+    this.timeExtent = undefined;
+    this.timeVisible = undefined;
+    this.view = undefined;
+    this.position = "bottom-left";
+    this.expandable = false;
+    this.widget = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  actionsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.actions = newValue;
+    }
+  }
+  fullTimeExtentWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.fullTimeExtent = newValue;
+    }
+  }
+  layoutWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.layout = newValue;
+    }
+  }
+  loopWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.loop = newValue;
+    }
+  }
+  modeWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.mode = newValue;
+    }
+  }
+  playRateWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.playRate = newValue;
+    }
+  }
+  stopsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.stops = newValue;
+    }
+  }
+  tickConfigsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.tickConfigs = newValue;
+    }
+  }
+  timeExtentWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.timeExtent = newValue;
+    }
+  }
+  timeVisibleWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.timeVisible = newValue;
+    }
+  }
+  positionWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      if (typeof this.view !== "string") {
+        this.view.ui.move(this.childElem, newValue);
+      }
+    }
+  }
+  referenceElementWatcher(newValue) {
+    referenceElementHelper(this, newValue);
+  }
+  viewWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.view = newValue;
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Methods
+  //
+  //--------------------------------------------------------------------------
+  async next() {
+    return this.widget?.next();
+  }
+  async play() {
+    return this.widget?.play();
+  }
+  async previous() {
+    return this.widget?.previous();
+  }
+  async stop() {
+    return this.widget?.stop();
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsTimeSlider(params);
+    this.widget = widget;
+    await this._addWatchers();
+    this._proxyEvents();
+    this.widgetReady.emit(true);
+    checkForView(this);
+  }
+  disconnectedCallback() {
+    onDisconnectedHelper(this);
+  }
+  render() {
+    if (this.expandable) {
+      return (h("arcgis-expand", { position: this.position, ref: (el) => (this.expandElem = el) }, h("div", { ref: (el) => (this.childElem = el) })));
+    }
+    return h("div", { ref: (el) => (this.childElem = el) });
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  //--------------------------------------------------------------------------
+  async _addWatchers() {
+    const { watch } = await importCoreReactiveUtils();
+    watch(() => this.widget.effectiveStops, (value) => (this.effectiveStops = value), {
+      initial: true
+    });
+  }
+  _createParams() {
+    const params = {
+      container: this.childElem
+    };
+    if (this.actions !== undefined) {
+      params.actions = this.actions;
+    }
+    if (this.fullTimeExtent !== undefined) {
+      params.fullTimeExtent = this.fullTimeExtent;
+    }
+    if (this.layout !== undefined) {
+      params.layout = this.layout;
+    }
+    if (this.loop !== undefined) {
+      params.loop = this.loop;
+    }
+    if (this.mode !== undefined) {
+      params.mode = this.mode;
+    }
+    if (this.playRate !== undefined) {
+      params.playRate = this.playRate;
+    }
+    if (this.stops !== undefined) {
+      params.stops = this.stops;
+    }
+    if (this.tickConfigs !== undefined) {
+      params.tickConfigs = this.tickConfigs;
+    }
+    if (this.timeExtent !== undefined) {
+      params.timeExtent = this.timeExtent;
+    }
+    if (this.timeVisible !== undefined) {
+      params.timeVisible = this.timeVisible;
+    }
+    if (this.view) {
+      params.view = this.view;
+    }
+    return params;
+  }
+  async _proxyEvents() {
+    this.widget?.on("trigger-action", (e) => this.triggerAction.emit(e));
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "actions": ["actionsWatcher"],
+    "fullTimeExtent": ["fullTimeExtentWatcher"],
+    "layout": ["layoutWatcher"],
+    "loop": ["loopWatcher"],
+    "mode": ["modeWatcher"],
+    "playRate": ["playRateWatcher"],
+    "stops": ["stopsWatcher"],
+    "tickConfigs": ["tickConfigsWatcher"],
+    "timeExtent": ["timeExtentWatcher"],
+    "timeVisible": ["timeVisibleWatcher"],
+    "position": ["positionWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+  static get style() { return arcgisTimeSliderCss; }
+}, [0, "arcgis-time-slider", {
+    "referenceElement": [1, "reference-element"],
+    "actions": [16],
+    "effectiveStops": [1040],
+    "fullTimeExtent": [16],
+    "layout": [1],
+    "loop": [4],
+    "mode": [1],
+    "playRate": [2, "play-rate"],
+    "stops": [16],
+    "tickConfigs": [16],
+    "timeExtent": [16],
+    "timeVisible": [4, "time-visible"],
+    "view": [16],
+    "position": [1],
+    "expandable": [4],
+    "widget": [1040],
+    "next": [64],
+    "play": [64],
+    "previous": [64],
+    "stop": [64]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["arcgis-time-slider", "arcgis-expand"];
+  components.forEach(tagName => { switch (tagName) {
+    case "arcgis-time-slider":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ArcgisTimeSlider$1);
+      }
+      break;
+    case "arcgis-expand":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const ArcgisTimeSlider = ArcgisTimeSlider$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisTimeSlider, defineCustomElement };

package/dist/components/arcgis-track.js

@@ -0,0 +1,171 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { $ as newWidgetsTrack, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, o as onDisconnectedHelper } from './disconnected.js';
+
+const arcgisTrackCss = "";
+
+const ArcgisTrack$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.trackComplete = createEvent(this, "trackComplete", 7);
+    this.trackError = createEvent(this, "trackError", 7);
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.geolocationOptions = undefined;
+    this.goToLocationEnabled = undefined;
+    this.graphic = undefined;
+    this.scale = undefined;
+    this.tracking = undefined;
+    this.useHeadingEnabled = undefined;
+    this.position = "bottom-left";
+    this.view = undefined;
+    this.widget = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  positionWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      if (typeof this.view !== "string") {
+        this.view.ui.move(this.childElem, newValue);
+      }
+    }
+  }
+  geolocationOptionsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.geolocationOptions = newValue;
+    }
+  }
+  goToLocationEnabledWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.goToLocationEnabled = newValue;
+    }
+  }
+  graphicWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.graphic = newValue;
+    }
+  }
+  scaleWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.scale = newValue;
+    }
+  }
+  useHeadingEnabledWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.useHeadingEnabled = newValue;
+    }
+  }
+  referenceElementWatcher(newValue) {
+    referenceElementHelper(this, newValue);
+  }
+  viewWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.view = newValue;
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsTrack(params);
+    this.widget = widget;
+    await this._addWatchers();
+    this._proxyEvents();
+    this.widgetReady.emit(true);
+    checkForView(this);
+  }
+  disconnectedCallback() {
+    onDisconnectedHelper(this);
+  }
+  render() {
+    return h("div", { ref: (el) => (this.childElem = el) });
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  //--------------------------------------------------------------------------
+  async _addWatchers() {
+    const { watch } = await importCoreReactiveUtils();
+    watch(() => this.widget.tracking, (value) => (this.tracking = value), {
+      initial: true
+    });
+  }
+  _createParams() {
+    const params = {
+      container: this.childElem
+    };
+    if (this.geolocationOptions !== undefined) {
+      params.geolocationOptions = this.geolocationOptions;
+    }
+    if (this.goToLocationEnabled !== undefined) {
+      params.goToLocationEnabled = this.goToLocationEnabled;
+    }
+    if (this.graphic !== undefined) {
+      params.graphic = this.graphic;
+    }
+    if (this.useHeadingEnabled !== undefined) {
+      params.useHeadingEnabled = this.useHeadingEnabled;
+    }
+    if (this.scale !== undefined) {
+      params.scale = this.scale;
+    }
+    if (this.view) {
+      params.view = this.view;
+    }
+    return params;
+  }
+  _proxyEvents() {
+    this.widget.on("track", (e) => this.trackComplete.emit(e));
+    this.widget.on("track-error", (e) => this.trackError.emit(e));
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "position": ["positionWatcher"],
+    "geolocationOptions": ["geolocationOptionsWatcher"],
+    "goToLocationEnabled": ["goToLocationEnabledWatcher"],
+    "graphic": ["graphicWatcher"],
+    "scale": ["scaleWatcher"],
+    "useHeadingEnabled": ["useHeadingEnabledWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+  static get style() { return arcgisTrackCss; }
+}, [0, "arcgis-track", {
+    "referenceElement": [1, "reference-element"],
+    "geolocationOptions": [8, "geolocation-options"],
+    "goToLocationEnabled": [4, "go-to-location-enabled"],
+    "graphic": [16],
+    "scale": [2],
+    "tracking": [1540],
+    "useHeadingEnabled": [4, "use-heading-enabled"],
+    "position": [1],
+    "view": [16],
+    "widget": [1040]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["arcgis-track"];
+  components.forEach(tagName => { switch (tagName) {
+    case "arcgis-track":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ArcgisTrack$1);
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const ArcgisTrack = ArcgisTrack$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisTrack, defineCustomElement };

package/dist/components/arcgis-utility-network-associations.d.ts

@@ -0,0 +1,11 @@
+import type { Components, JSX } from "../types/components";
+
+interface ArcgisUtilityNetworkAssociations extends Components.ArcgisUtilityNetworkAssociations, HTMLElement {}
+export const ArcgisUtilityNetworkAssociations: {
+  prototype: ArcgisUtilityNetworkAssociations;
+  new (): ArcgisUtilityNetworkAssociations;
+};
+/**
+ * Used to define this component and all nested components recursively.
+ */
+export const defineCustomElement: () => void;

package/dist/components/arcgis-utility-network-associations.js

@@ -0,0 +1,258 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { a0 as newWidgetsUtilityNetworkAssociations } from './index2.js';
+import { u as updateForView, c as checkForView, o as onDisconnectedHelper } from './disconnected.js';
+import { d as defineCustomElement$2 } from './arcgis-expand2.js';
+
+const arcgisUtilityNetworkAssociationsCss = "arcgis-utility-network-associations{}";
+
+const ArcgisUtilityNetworkAssociations$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.autoRefreshAssociations = undefined;
+    this.connectivityAssociationsLineSymbol = undefined;
+    this.includeConnectivityAssociations = undefined;
+    this.includeStructuralAttachmentAssociations = undefined;
+    this.maxAllowableAssociations = undefined;
+    this.maxAllowableAssociationsSliderMax = undefined;
+    this.maxAllowableAssociationsSliderMin = undefined;
+    this.maxAllowableAssociationsSliderStep = undefined;
+    this.showArrowsConnectivity = undefined;
+    this.showArrowsStructuralAttachment = undefined;
+    this.showAssociationsEnabled = undefined;
+    this.structuralAttachmentAssociationsLineSymbol = undefined;
+    this.utilityNetwork = undefined;
+    this.view = undefined;
+    this.position = "bottom-left";
+    this.expandable = false;
+    this.widget = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  positionWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      if (typeof this.view !== "string") {
+        this.view.ui.move(this.childElem, newValue);
+      }
+    }
+  }
+  autoRefreshAssociationsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.autoRefreshAssociations = newValue;
+    }
+  }
+  connectivityAssociationsLineSymbolWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.connectivityAssociationsLineSymbol = newValue;
+    }
+  }
+  includeConnectivityAssociationsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.includeConnectivityAssociations = newValue;
+    }
+  }
+  includeStructuralAttachmentAssociationsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.includeStructuralAttachmentAssociations = newValue;
+    }
+  }
+  maxAllowableAssociationsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.maxAllowableAssociations = newValue;
+    }
+  }
+  maxAllowableAssociationsSliderMaxWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.maxAllowableAssociationsSliderMax = newValue;
+    }
+  }
+  maxAllowableAssociationsSliderMinWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.maxAllowableAssociationsSliderMin = newValue;
+    }
+  }
+  maxAllowableAssociationsSliderStepWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.maxAllowableAssociationsSliderStep = newValue;
+    }
+  }
+  showArrowsConnectivityWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.showArrowsConnectivity = newValue;
+    }
+  }
+  showArrowsStructuralAttachmentWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.showArrowsStructuralAttachment = newValue;
+    }
+  }
+  showAssociationsEnabledWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.showAssociationsEnabled = newValue;
+    }
+  }
+  structuralAttachmentAssociationsLineSymbolWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.structuralAttachmentAssociationsLineSymbol = newValue;
+    }
+  }
+  utilityNetworkWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.utilityNetwork = newValue;
+    }
+  }
+  referenceElementWatcher(newValue) {
+    if (typeof newValue === "string") {
+      updateForView(newValue).then((view) => {
+        this.widget.view = view;
+      });
+    }
+    else if (newValue !== undefined && this.widget) {
+      this.widget.view = newValue.view;
+    }
+  }
+  viewWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.view = newValue;
+    }
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsUtilityNetworkAssociations(params);
+    this.widget = widget;
+    this.widgetReady.emit(true);
+    checkForView(this);
+  }
+  disconnectedCallback() {
+    onDisconnectedHelper(this);
+  }
+  render() {
+    if (this.expandable) {
+      return (h("arcgis-expand", { position: this.position, ref: (el) => (this.expandElem = el) }, h("div", { ref: (el) => (this.childElem = el) })));
+    }
+    return h("div", { ref: (el) => (this.childElem = el) });
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Private Methods
+  //
+  //--------------------------------------------------------------------------
+  _createParams() {
+    const params = {
+      container: this.childElem
+    };
+    if (this.autoRefreshAssociations !== undefined) {
+      params.autoRefreshAssociations = this.autoRefreshAssociations;
+    }
+    if (this.connectivityAssociationsLineSymbol !== undefined) {
+      params.connectivityAssociationsLineSymbol = this.connectivityAssociationsLineSymbol;
+    }
+    if (this.includeConnectivityAssociations !== undefined) {
+      params.includeConnectivityAssociations = this.includeConnectivityAssociations;
+    }
+    if (this.includeStructuralAttachmentAssociations !== undefined) {
+      params.includeStructuralAttachmentAssociations = this.includeStructuralAttachmentAssociations;
+    }
+    if (this.maxAllowableAssociations !== undefined) {
+      params.maxAllowableAssociations = this.maxAllowableAssociations;
+    }
+    if (this.maxAllowableAssociationsSliderMax !== undefined) {
+      params.maxAllowableAssociationsSliderMax = this.maxAllowableAssociationsSliderMax;
+    }
+    if (this.maxAllowableAssociationsSliderMin !== undefined) {
+      params.maxAllowableAssociationsSliderMin = this.maxAllowableAssociationsSliderMin;
+    }
+    if (this.maxAllowableAssociationsSliderStep !== undefined) {
+      params.maxAllowableAssociationsSliderStep = this.maxAllowableAssociationsSliderStep;
+    }
+    if (this.showArrowsConnectivity !== undefined) {
+      params.showArrowsConnectivity = this.showArrowsConnectivity;
+    }
+    if (this.showArrowsStructuralAttachment !== undefined) {
+      params.showArrowsStructuralAttachment = this.showArrowsStructuralAttachment;
+    }
+    if (this.showAssociationsEnabled !== undefined) {
+      params.showAssociationsEnabled = this.showAssociationsEnabled;
+    }
+    if (this.structuralAttachmentAssociationsLineSymbol !== undefined) {
+      params.structuralAttachmentAssociationsLineSymbol = this.structuralAttachmentAssociationsLineSymbol;
+    }
+    if (this.utilityNetwork !== undefined) {
+      params.utilityNetwork = this.utilityNetwork;
+    }
+    return params;
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "position": ["positionWatcher"],
+    "autoRefreshAssociations": ["autoRefreshAssociationsWatcher"],
+    "connectivityAssociationsLineSymbol": ["connectivityAssociationsLineSymbolWatcher"],
+    "includeConnectivityAssociations": ["includeConnectivityAssociationsWatcher"],
+    "includeStructuralAttachmentAssociations": ["includeStructuralAttachmentAssociationsWatcher"],
+    "maxAllowableAssociations": ["maxAllowableAssociationsWatcher"],
+    "maxAllowableAssociationsSliderMax": ["maxAllowableAssociationsSliderMaxWatcher"],
+    "maxAllowableAssociationsSliderMin": ["maxAllowableAssociationsSliderMinWatcher"],
+    "maxAllowableAssociationsSliderStep": ["maxAllowableAssociationsSliderStepWatcher"],
+    "showArrowsConnectivity": ["showArrowsConnectivityWatcher"],
+    "showArrowsStructuralAttachment": ["showArrowsStructuralAttachmentWatcher"],
+    "showAssociationsEnabled": ["showAssociationsEnabledWatcher"],
+    "structuralAttachmentAssociationsLineSymbol": ["structuralAttachmentAssociationsLineSymbolWatcher"],
+    "utilityNetwork": ["utilityNetworkWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+  static get style() { return arcgisUtilityNetworkAssociationsCss; }
+}, [0, "arcgis-utility-network-associations", {
+    "referenceElement": [1, "reference-element"],
+    "autoRefreshAssociations": [4, "auto-refresh-associations"],
+    "connectivityAssociationsLineSymbol": [16],
+    "includeConnectivityAssociations": [4, "include-connectivity-associations"],
+    "includeStructuralAttachmentAssociations": [4, "include-structural-attachment-associations"],
+    "maxAllowableAssociations": [2, "max-allowable-associations"],
+    "maxAllowableAssociationsSliderMax": [2, "max-allowable-associations-slider-max"],
+    "maxAllowableAssociationsSliderMin": [2, "max-allowable-associations-slider-min"],
+    "maxAllowableAssociationsSliderStep": [2, "max-allowable-associations-slider-step"],
+    "showArrowsConnectivity": [4, "show-arrows-connectivity"],
+    "showArrowsStructuralAttachment": [4, "show-arrows-structural-attachment"],
+    "showAssociationsEnabled": [4, "show-associations-enabled"],
+    "structuralAttachmentAssociationsLineSymbol": [16],
+    "utilityNetwork": [16],
+    "view": [16],
+    "position": [1],
+    "expandable": [4],
+    "widget": [1040]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["arcgis-utility-network-associations", "arcgis-expand"];
+  components.forEach(tagName => { switch (tagName) {
+    case "arcgis-utility-network-associations":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ArcgisUtilityNetworkAssociations$1);
+      }
+      break;
+    case "arcgis-expand":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const ArcgisUtilityNetworkAssociations = ArcgisUtilityNetworkAssociations$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisUtilityNetworkAssociations, defineCustomElement };