@arcgis/map-components 1.0.0-beta.14

package/dist/esm/arcgis-utility-network-trace.entry.js

@@ -0,0 +1,158 @@
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-eb3ead33.js';
+import { a0 as newWidgetsUtilityNetworkTrace } from './index-ad26b6d0.js';
+import { r as referenceElementHelper, c as checkForView } from './component-utils-d3552de2.js';
+import { o as onDisconnectedHelper } from './disconnected-bc5fc8bc.js';
+
+const arcgisUtilityNetworkTraceCss = "";
+
+const ArcgisUtilityNetworkTrace = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    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 getElement(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"]
+  }; }
+};
+ArcgisUtilityNetworkTrace.style = arcgisUtilityNetworkTraceCss;
+
+export { ArcgisUtilityNetworkTrace as arcgis_utility_network_trace };

package/dist/esm/arcgis-value-picker.entry.js

@@ -0,0 +1,156 @@
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-eb3ead33.js';
+import { a1 as newWidgetsValuePicker, i as importCoreReactiveUtils } from './index-ad26b6d0.js';
+import { c as checkForView } from './component-utils-d3552de2.js';
+import { o as onDisconnectedHelper } from './disconnected-bc5fc8bc.js';
+
+const arcgisValuePickerCss = "arcgis-value-picker{}";
+
+const ArcgisValuePicker = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    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 getElement(this); }
+  static get watchers() { return {
+    "position": ["positionWatcher"],
+    "caption": ["captionWatcher"],
+    "component": ["componentWatcher"],
+    "layout": ["layoutWatcher"],
+    "loop": ["loopWatcher"],
+    "playRate": ["playRateWatcher"]
+  }; }
+};
+ArcgisValuePicker.style = arcgisValuePickerCss;
+
+export { ArcgisValuePicker as arcgis_value_picker };

package/dist/esm/arcgis-weather.entry.js

@@ -0,0 +1,82 @@
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-eb3ead33.js';
+import { a2 as newWidgetsWeather } from './index-ad26b6d0.js';
+import { r as referenceElementHelper, c as checkForView } from './component-utils-d3552de2.js';
+import { o as onDisconnectedHelper } from './disconnected-bc5fc8bc.js';
+
+const arcgisWeatherCss = "";
+
+const ArcgisWeather = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.position = "bottom-left";
+    this.expandable = false;
+    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);
+      }
+    }
+  }
+  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 newWidgetsWeather(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.view) {
+      params.view = this.view;
+    }
+    return params;
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "position": ["positionWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+};
+ArcgisWeather.style = arcgisWeatherCss;
+
+export { ArcgisWeather as arcgis_weather };

package/dist/esm/arcgis-zoom.entry.js

@@ -0,0 +1,96 @@
+import { r as registerInstance, c as createEvent, h, g as getElement } from './index-eb3ead33.js';
+import { a3 as newWidgetsZoom } from './index-ad26b6d0.js';
+import { r as referenceElementHelper, c as checkForView } from './component-utils-d3552de2.js';
+import { o as onDisconnectedHelper } from './disconnected-bc5fc8bc.js';
+
+const arcgisZoomCss = "arcgis-zoom{}";
+
+const ArcgisZoom = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.widgetReady = createEvent(this, "widgetReady", 7);
+    this.referenceElement = undefined;
+    this.layout = undefined;
+    this.view = undefined;
+    this.position = "bottom-left";
+    this.widget = undefined;
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Watchers
+  //
+  //--------------------------------------------------------------------------
+  layoutWatcher(newValue) {
+    if (newValue !== undefined && this.widget) {
+      this.widget.layout = 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 zoomIn() {
+    return this.widget?.zoomIn();
+  }
+  async zoomOut() {
+    return this.widget?.zoomOut();
+  }
+  //--------------------------------------------------------------------------
+  //
+  //  Lifecycle
+  //
+  //--------------------------------------------------------------------------
+  async componentDidLoad() {
+    const params = this._createParams();
+    const widget = await newWidgetsZoom(params);
+    this.widget = widget;
+    this.widgetReady.emit(true);
+    checkForView(this);
+  }
+  disconnectedCallback() {
+    onDisconnectedHelper(this);
+  }
+  render() {
+    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;
+  }
+  get el() { return getElement(this); }
+  static get watchers() { return {
+    "layout": ["layoutWatcher"],
+    "position": ["positionWatcher"],
+    "referenceElement": ["referenceElementWatcher"],
+    "view": ["viewWatcher"]
+  }; }
+};
+ArcgisZoom.style = arcgisZoomCss;
+
+export { ArcgisZoom as arcgis_zoom };

package/dist/esm/component-utils-d3552de2.js

@@ -0,0 +1,73 @@
+import { c as checkForExpand } from './disconnected-bc5fc8bc.js';
+
+//--------------------------------------------------------------------------
+//
+//  Public Methods
+//
+//--------------------------------------------------------------------------
+function checkForView(element) {
+  let isDetached = false;
+  if (!checkForExpand(element)) {
+    let viewRef = element.el.closest("arcgis-map") || element.el.closest("arcgis-scene");
+    if (!viewRef && typeof element.referenceElement === "string") {
+      viewRef = document.querySelector(element.referenceElement);
+      isDetached = true;
+    }
+    if (viewRef?.view && typeof viewRef?.view !== "string") {
+      element.view = viewRef.view;
+      const el = element.childElem || element.el;
+      if (!isDetached) {
+        element.view.ui.add(el, element.position);
+      }
+    }
+    else if (viewRef) {
+      waitForViewHandler(viewRef, element, isDetached);
+    }
+  }
+}
+async function updateForView(viewStr) {
+  const viewRef = document.querySelector(viewStr);
+  return new Promise((resolve) => {
+    if (viewRef?.view !== undefined) {
+      resolve(viewRef.view);
+    }
+    else if (viewRef) {
+      const handler = () => {
+        viewRef.removeEventListener("viewReady", handler, false);
+        resolve(viewRef.view);
+      };
+      viewRef.addEventListener("viewReady", handler, false);
+    }
+  });
+}
+async function referenceElementHelper(element, refElement) {
+  if (typeof refElement === "string") {
+    element.view = await updateForView(refElement);
+  }
+  else if (refElement !== undefined && element.widget) {
+    element.view = refElement.view;
+  }
+  return;
+}
+//--------------------------------------------------------------------------
+//
+//  Private Methods
+//
+//--------------------------------------------------------------------------
+function waitForViewHandler(viewRef, element, isDetached) {
+  const handler = () => {
+    viewRef?.removeEventListener("viewReady", handler, false);
+    element.view = viewRef?.view;
+    if (!isDetached && typeof element.view !== "string") {
+      if (element.childElem) {
+        element.view?.ui.add(element.childElem, element.position);
+      }
+      else {
+        element.view?.ui.add(element.el, element.position);
+      }
+    }
+  };
+  viewRef.addEventListener("viewReady", handler, false);
+}
+
+export { checkForView as c, referenceElementHelper as r };

package/dist/esm/disconnected-bc5fc8bc.js

@@ -0,0 +1,52 @@
+function checkForExpand(element) {
+  const expandRef = element.el.closest("arcgis-expand") || element.expandElem;
+  if (expandRef?.widget) {
+    element.view = expandRef.view;
+    expandRef.widget.content = element.childElem;
+    // TODO: Update to be expandIcon = widget.icon, not ready yet in 4.27next
+    expandRef.widget.expandIcon = element.widget.icon;
+    expandRef.widget.expandIconClass = element.widget.iconClass;
+    return true;
+  }
+  if (expandRef) {
+    const widgetHandler = () => {
+      element.view = expandRef.view;
+      expandRef.widget.content = element.childElem;
+      expandRef.widget.expandIcon = element.widget.icon;
+      expandRef.widget.expandIconClass = element.widget.iconClass;
+      expandRef.removeEventListener("widgetReady", widgetHandler, false);
+    };
+    expandRef.addEventListener("widgetReady", widgetHandler, false);
+    return true;
+  }
+  return false;
+}
+
+function onDisconnectedHelper(element) {
+  if (element.childElem) {
+    if (!element.el.isConnected) {
+      if (element.view && typeof element.view !== "string") {
+        element.view.ui.remove(element.childElem);
+      }
+      else if (element.widget?.view) {
+        element.widget.view.ui.remove(element.childElem);
+      }
+      element.widget?.destroy();
+    }
+  }
+  else {
+    setTimeout(() => {
+      if (!element.el.isConnected) {
+        if (element.view && typeof element.view !== "string") {
+          element.view.ui.remove(element.el);
+        }
+        else if (element.widget?.view) {
+          element.widget.view.ui.remove(element.el);
+        }
+        element.widget?.destroy();
+      }
+    }, 1000);
+  }
+}
+
+export { checkForExpand as c, onDisconnectedHelper as o };