@arcgis/map-components 1.0.0-beta.14

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-trace.d.ts

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

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

@@ -0,0 +1,197 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { $ as newWidgetsUtilityNetworkTrace } 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 arcgisUtilityNetworkTraceCss = "";
+
+const ArcgisUtilityNetworkTrace$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.traceAddFlag = createEvent(this, "traceAddFlag", 7);
+    this.traceAddFlagComplete = createEvent(this, "traceAddFlagComplete", 7);
+    this.traceAddFlagError = createEvent(this, "traceAddFlagError", 7);
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.defaultGraphicColor = undefined;
+    this.flags = undefined;
+    this.gdbVersion = undefined;
+    this.inputSettings = undefined;
+    this.selectedTraces = undefined;
+    this.selectOnComplete = undefined;
+    this.showGraphicsOnComplete = undefined;
+    this.showSelectionAttributes = undefined;
+    this.position = "bottom-left";
+    this.expandable = false;
+    this.view = undefined;
+    this.widget = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  defaultGraphicColorWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.defaultGraphicColor = newValue;
+    }
+  }
+  flagsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.flags = newValue;
+    }
+  }
+  gdbVersionWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.gdbVersion = newValue;
+    }
+  }
+  inputSettingsWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.inputSettings = newValue;
+    }
+  }
+  selectedTracesWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.selectedTraces = newValue;
+    }
+  }
+  selectOnCompleteWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.selectOnComplete = newValue;
+    }
+  }
+  showGraphicsOnCompleteWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.showGraphicsOnComplete = newValue;
+    }
+  }
+  showSelectionAttributesWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.showSelectionAttributes = 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 checkCanTrace() {
+    return this.widget?.checkCanTrace();
+  }
+  async confirmReset() {
+    return this.widget?.confirmReset();
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsUtilityNetworkTrace(params);
+    this.widget = widget;
+    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
+  //
+  //--------------------------------------------------------------------------
+  _createParams() {
+    const params = {
+      container: this.childElem
+    };
+    if (this.view) {
+      params.view = this.view;
+    }
+    return params;
+  }
+  _proxyEvents() {
+    this.widget.on("add-flag", (e) => this.traceAddFlag.emit(e));
+    this.widget.on("add-flag-complete", (e) => this.traceAddFlagComplete.emit(e));
+    this.widget.on("add-flag-error", (e) => this.traceAddFlagError.emit(e));
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "defaultGraphicColor": ["defaultGraphicColorWatcher"],
+    "flags": ["flagsWatcher"],
+    "gdbVersion": ["gdbVersionWatcher"],
+    "inputSettings": ["inputSettingsWatcher"],
+    "selectedTraces": ["selectedTracesWatcher"],
+    "selectOnComplete": ["selectOnCompleteWatcher"],
+    "showGraphicsOnComplete": ["showGraphicsOnCompleteWatcher"],
+    "showSelectionAttributes": ["showSelectionAttributesWatcher"],
+    "position": ["positionWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+  static get style() { return arcgisUtilityNetworkTraceCss; }
+}, [0, "arcgis-utility-network-trace", {
+    "referenceElement": [1, "reference-element"],
+    "defaultGraphicColor": [16],
+    "flags": [16],
+    "gdbVersion": [1, "gdb-version"],
+    "inputSettings": [16],
+    "selectedTraces": [16],
+    "selectOnComplete": [4, "select-on-complete"],
+    "showGraphicsOnComplete": [4, "show-graphics-on-complete"],
+    "showSelectionAttributes": [4, "show-selection-attributes"],
+    "position": [1],
+    "expandable": [4],
+    "view": [16],
+    "widget": [1040],
+    "checkCanTrace": [64],
+    "confirmReset": [64]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["arcgis-utility-network-trace", "arcgis-expand"];
+  components.forEach(tagName => { switch (tagName) {
+    case "arcgis-utility-network-trace":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ArcgisUtilityNetworkTrace$1);
+      }
+      break;
+    case "arcgis-expand":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const ArcgisUtilityNetworkTrace = ArcgisUtilityNetworkTrace$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisUtilityNetworkTrace, defineCustomElement };

package/dist/components/arcgis-value-picker.d.ts

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

package/dist/components/arcgis-value-picker.js

@@ -0,0 +1,198 @@
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { a0 as newWidgetsValuePicker, i as importCoreReactiveUtils } from './index2.js';
+import { c as checkForView, o as onDisconnectedHelper } from './disconnected.js';
+import { d as defineCustomElement$2 } from './arcgis-expand2.js';
+
+const arcgisValuePickerCss = "arcgis-value-picker{}";
+
+const ArcgisValuePicker$1 = /*@__PURE__*/ proxyCustomElement(class extends HTMLElement {
+  constructor() {
+    super();
+    this.__registerHost();
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.valuePickerAnimate = createEvent(this, "valuePickerAnimate", 7);
+    this.valuePickerNext = createEvent(this, "valuePickerNext", 7);
+    this.valuePickerPause = createEvent(this, "valuePickerPause", 7);
+    this.valuePickerPlay = createEvent(this, "valuePickerPlay", 7);
+    this.valuePickerPrevious = createEvent(this, "valuePickerPrevious", 7);
+    this.referenceElement = undefined;
+    this.view = undefined;
+    this.position = "bottom-left";
+    this.expandable = false;
+    this.widget = undefined;
+    this.canNext = undefined;
+    this.canPlay = undefined;
+    this.canPrevious = undefined;
+    this.caption = undefined;
+    this.component = undefined;
+    this.layout = undefined;
+    this.loop = undefined;
+    this.playRate = undefined;
+    this.values = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  positionWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      if (typeof this.view !== "string") {
+        this.view.ui.move(this.childElem, newValue);
+      }
+    }
+  }
+  captionWatcher(newValue) {
+    this.widget.caption = newValue;
+  }
+  componentWatcher(newValue) {
+    this.widget.component = newValue;
+  }
+  layoutWatcher(newValue) {
+    this.widget.layout = newValue;
+  }
+  loopWatcher(newValue) {
+    this.widget.loop = newValue;
+  }
+  playRateWatcher(newValue) {
+    this.widget.playRate = newValue;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Methods
+  //
+  //--------------------------------------------------------------------------
+  async next() {
+    return this.widget?.next();
+  }
+  async pause() {
+    return this.widget?.pause();
+  }
+  async play() {
+    return this.widget?.play();
+  }
+  async previous() {
+    return this.widget?.previous();
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsValuePicker(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 Interal Methods
+  //
+  //--------------------------------------------------------------------------
+  async _addWatchers() {
+    const { watch } = await importCoreReactiveUtils();
+    watch(() => this.widget.canNext, (value) => (this.canNext = value), {
+      initial: true
+    });
+    watch(() => this.widget.canPlay, (value) => (this.canPlay = value), {
+      initial: true
+    });
+    watch(() => this.widget.canPrevious, (value) => (this.canPrevious = value), {
+      initial: true
+    });
+  }
+  _createParams() {
+    const params = {
+      container: this.childElem
+    };
+    if (this.caption) {
+      params.caption = this.caption;
+    }
+    if (this.component) {
+      params.component = this.component;
+    }
+    if (this.layout) {
+      params.layout = this.layout;
+    }
+    if (this.loop) {
+      params.loop = this.loop;
+    }
+    if (this.playRate) {
+      params.playRate = this.playRate;
+    }
+    return params;
+  }
+  _proxyEvents() {
+    this.widget.on("animate", (e) => this.valuePickerAnimate.emit(e));
+    this.widget.on("next", (e) => this.valuePickerNext.emit(e));
+    this.widget.on("pause", (e) => this.valuePickerPause.emit(e));
+    this.widget.on("play", (e) => this.valuePickerPlay.emit(e));
+    this.widget.on("previous", (e) => this.valuePickerPrevious.emit(e));
+  }
+  get el() { return this; }
+  static get watchers() { return {
+    "position": ["positionWatcher"],
+    "caption": ["captionWatcher"],
+    "component": ["componentWatcher"],
+    "layout": ["layoutWatcher"],
+    "loop": ["loopWatcher"],
+    "playRate": ["playRateWatcher"]
+  }; }
+  static get style() { return arcgisValuePickerCss; }
+}, [0, "arcgis-value-picker", {
+    "referenceElement": [1, "reference-element"],
+    "view": [16],
+    "position": [1],
+    "expandable": [4],
+    "widget": [1040],
+    "canNext": [516, "can-next"],
+    "canPlay": [516, "can-play"],
+    "canPrevious": [516, "can-previous"],
+    "caption": [1],
+    "component": [16],
+    "layout": [1],
+    "loop": [4],
+    "playRate": [2, "play-rate"],
+    "values": [1040],
+    "next": [64],
+    "pause": [64],
+    "play": [64],
+    "previous": [64]
+  }]);
+function defineCustomElement$1() {
+  if (typeof customElements === "undefined") {
+    return;
+  }
+  const components = ["arcgis-value-picker", "arcgis-expand"];
+  components.forEach(tagName => { switch (tagName) {
+    case "arcgis-value-picker":
+      if (!customElements.get(tagName)) {
+        customElements.define(tagName, ArcgisValuePicker$1);
+      }
+      break;
+    case "arcgis-expand":
+      if (!customElements.get(tagName)) {
+        defineCustomElement$2();
+      }
+      break;
+  } });
+}
+defineCustomElement$1();
+
+const ArcgisValuePicker = ArcgisValuePicker$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisValuePicker, defineCustomElement };

package/dist/components/arcgis-weather.d.ts

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