@arcgis/map-components 4.29.0-test.0 → 4.29.0

package/dist/components/arcgis-table-list.js

@@ -0,0 +1,342 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+import { proxyCustomElement, HTMLElement, createEvent, h } from '@stencil/core/internal/client';
+import { Z as newWidgetsTableList, i as importCoreReactiveUtils } from './index2.js';
+import { r as referenceElementHelper, c as checkForView, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const tableListCss = "arcgis-table-list{}";
+
+const ArcgisTableList$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisTableList extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisTableListReady = createEvent(this, "arcgisTableListReady", 7);
+        this.tableListTriggerAction = createEvent(this, "tableListTriggerAction", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.collapsed = false;
+        this.dragEnabled = false;
+        this.filterPlaceholder = "";
+        this.filterText = "";
+        this.icon = undefined;
+        this.minDragEnabledItems = 2;
+        this.minFilterItems = 10;
+        this.selectedItems = undefined;
+        this.selectionMode = "none";
+        this.listItemCreatedFunction = undefined;
+        this.visibleElementsCloseButton = false;
+        this.visibleElementsCollapseButton = false;
+        this.visibleElementsErrors = false;
+        this.visibleElementsFilter = false;
+        this.visibleElementsFlow = true;
+        this.visibleElementsHeading = false;
+        this.visibleElementsStatusIndicators = true;
+        this.visibleElementsTemporaryTableIndicators = false;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(newValue) {
+        void referenceElementHelper(this, newValue);
+    }
+    collapsedWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.collapsed = value;
+        }
+    }
+    dragEnabledWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.dragEnabled = value;
+        }
+    }
+    filterPlaceholderWatcher(value) {
+        if (this.widget) {
+            this.widget.filterPlaceholder = value;
+        }
+    }
+    filterTextWatcher(value) {
+        if (this.widget) {
+            this.widget.filterText = value;
+        }
+    }
+    iconWatcher(value) {
+        if (this.widget) {
+            this.widget.icon = value;
+        }
+    }
+    minDragEnabledItemsWatcher(value) {
+        if (this.widget) {
+            this.widget.minDragEnabledItems = value;
+        }
+    }
+    minFilterItemsWatcher(value) {
+        if (this.widget) {
+            this.widget.minFilterItems = value;
+        }
+    }
+    selectedItemsWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.selectedItems = value;
+        }
+    }
+    selectionModeWatcher(value) {
+        if (this.widget) {
+            this.widget.selectionMode = value;
+        }
+    }
+    listItemCreatedFunctionWatcher(newValue) {
+        if (this.widget) {
+            this.widget.listItemCreatedFunction = newValue;
+        }
+    }
+    visibleElementsCloseButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                closeButton: value
+            };
+        }
+    }
+    visibleElementsCollapseButtonWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                collapseButton: value
+            };
+        }
+    }
+    visibleElementsErrorsWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                errors: value
+            };
+        }
+    }
+    visibleElementsFilterWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                filter: value
+            };
+        }
+    }
+    visibleElementsFlowWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                flow: value
+            };
+        }
+    }
+    visibleElementsHeadingWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                heading: value
+            };
+        }
+    }
+    visibleElementsStatusIndicatorsWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                statusIndicators: value
+            };
+        }
+    }
+    visibleElementsTemporaryTableIndicatorsWatcher(value) {
+        if (this.widget) {
+            this.widget.visibleElements = {
+                ...this.widget.visibleElements,
+                temporaryTableIndicators: value
+            };
+        }
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, newValue);
+        }
+    }
+    viewWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.map = newValue.map;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsTableList(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this._addContainer();
+        this.arcgisTableListReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, watch(() => this.widget.selectedItems, (value) => (this.selectedItems = value)));
+    }
+    _createParams() {
+        const params = {};
+        params.visibleElements = {
+            closeButton: this.visibleElementsCloseButton,
+            collapseButton: this.visibleElementsCollapseButton,
+            errors: this.visibleElementsErrors,
+            filter: this.visibleElementsFilter,
+            flow: this.visibleElementsFlow,
+            heading: this.visibleElementsHeading,
+            statusIndicators: this.visibleElementsStatusIndicators,
+            temporaryTableIndicators: this.visibleElementsTemporaryTableIndicators
+        };
+        if (this.collapsed !== undefined) {
+            params.collapsed = this.collapsed;
+        }
+        if (this.dragEnabled !== undefined) {
+            params.dragEnabled = this.dragEnabled;
+        }
+        if (this.filterPlaceholder) {
+            params.filterPlaceholder = this.filterPlaceholder;
+        }
+        if (this.filterText) {
+            params.filterText = this.filterText;
+        }
+        if (this.icon) {
+            params.icon = this.icon;
+        }
+        if (this.listItemCreatedFunction) {
+            params.listItemCreatedFunction = this.listItemCreatedFunction;
+        }
+        if (this.minDragEnabledItems !== undefined) {
+            params.minDragEnabledItems = this.minDragEnabledItems;
+        }
+        if (this.minFilterItems !== undefined) {
+            params.minFilterItems = this.minFilterItems;
+        }
+        if (this.selectedItems) {
+            params.selectedItems = this.selectedItems;
+        }
+        if (this.selectionMode) {
+            params.selectionMode = this.selectionMode;
+        }
+        if (this.view) {
+            params.map = this.view.map;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget?.on("trigger-action", (e) => this.tableListTriggerAction.emit(e));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "collapsed": ["collapsedWatcher"],
+        "dragEnabled": ["dragEnabledWatcher"],
+        "filterPlaceholder": ["filterPlaceholderWatcher"],
+        "filterText": ["filterTextWatcher"],
+        "icon": ["iconWatcher"],
+        "minDragEnabledItems": ["minDragEnabledItemsWatcher"],
+        "minFilterItems": ["minFilterItemsWatcher"],
+        "selectedItems": ["selectedItemsWatcher"],
+        "selectionMode": ["selectionModeWatcher"],
+        "listItemCreatedFunction": ["listItemCreatedFunctionWatcher"],
+        "visibleElementsCloseButton": ["visibleElementsCloseButtonWatcher"],
+        "visibleElementsCollapseButton": ["visibleElementsCollapseButtonWatcher"],
+        "visibleElementsErrors": ["visibleElementsErrorsWatcher"],
+        "visibleElementsFilter": ["visibleElementsFilterWatcher"],
+        "visibleElementsFlow": ["visibleElementsFlowWatcher"],
+        "visibleElementsHeading": ["visibleElementsHeadingWatcher"],
+        "visibleElementsStatusIndicators": ["visibleElementsStatusIndicatorsWatcher"],
+        "visibleElementsTemporaryTableIndicators": ["visibleElementsTemporaryTableIndicatorsWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return tableListCss; }
+}, [0, "arcgis-table-list", {
+        "referenceElement": [1, "reference-element"],
+        "collapsed": [4],
+        "dragEnabled": [4, "drag-enabled"],
+        "filterPlaceholder": [1, "filter-placeholder"],
+        "filterText": [1, "filter-text"],
+        "icon": [1],
+        "minDragEnabledItems": [2, "min-drag-enabled-items"],
+        "minFilterItems": [2, "min-filter-items"],
+        "selectedItems": [1040],
+        "selectionMode": [1, "selection-mode"],
+        "listItemCreatedFunction": [16],
+        "visibleElementsCloseButton": [4, "visible-elements-close-button"],
+        "visibleElementsCollapseButton": [4, "visible-elements-collapse-button"],
+        "visibleElementsErrors": [4, "visible-elements-errors"],
+        "visibleElementsFilter": [4, "visible-elements-filter"],
+        "visibleElementsFlow": [4, "visible-elements-flow"],
+        "visibleElementsHeading": [4, "visible-elements-heading"],
+        "visibleElementsStatusIndicators": [4, "visible-elements-status-indicators"],
+        "visibleElementsTemporaryTableIndicators": [4, "visible-elements-temporary-table-indicators"],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "collapsed": ["collapsedWatcher"],
+        "dragEnabled": ["dragEnabledWatcher"],
+        "filterPlaceholder": ["filterPlaceholderWatcher"],
+        "filterText": ["filterTextWatcher"],
+        "icon": ["iconWatcher"],
+        "minDragEnabledItems": ["minDragEnabledItemsWatcher"],
+        "minFilterItems": ["minFilterItemsWatcher"],
+        "selectedItems": ["selectedItemsWatcher"],
+        "selectionMode": ["selectionModeWatcher"],
+        "listItemCreatedFunction": ["listItemCreatedFunctionWatcher"],
+        "visibleElementsCloseButton": ["visibleElementsCloseButtonWatcher"],
+        "visibleElementsCollapseButton": ["visibleElementsCollapseButtonWatcher"],
+        "visibleElementsErrors": ["visibleElementsErrorsWatcher"],
+        "visibleElementsFilter": ["visibleElementsFilterWatcher"],
+        "visibleElementsFlow": ["visibleElementsFlowWatcher"],
+        "visibleElementsHeading": ["visibleElementsHeadingWatcher"],
+        "visibleElementsStatusIndicators": ["visibleElementsStatusIndicatorsWatcher"],
+        "visibleElementsTemporaryTableIndicators": ["visibleElementsTemporaryTableIndicatorsWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-table-list"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-table-list":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisTableList$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisTableList = ArcgisTableList$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisTableList, defineCustomElement };

package/{components → dist/components}/arcgis-time-slider.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisTimeSlider extends Components.ArcgisTimeSlider, HTMLElement {}
 export const ArcgisTimeSlider: {
-  prototype: ArcgisTimeSlider;
-  new (): ArcgisTimeSlider;
+    prototype: ArcgisTimeSlider;
+    new (): ArcgisTimeSlider;
 };
 /**
  * Used to define this component and all nested components recursively.

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

@@ -0,0 +1,289 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.0
+ */
+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, a as addHandles } from './component-utils.js';
+import { o as onDisconnectedHelper } from './disconnected.js';
+
+const timeSliderCss = "arcgis-time-slider{}";
+
+const ArcgisTimeSlider$1 = /*@__PURE__*/ proxyCustomElement(class ArcgisTimeSlider extends HTMLElement {
+    constructor() {
+        super();
+        this.__registerHost();
+        this.arcgisTimeSliderReady = createEvent(this, "arcgisTimeSliderReady", 7);
+        this.timeSliderTriggerAction = createEvent(this, "timeSliderTriggerAction", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.actions = undefined;
+        this.disabled = false;
+        this.effectiveStops = undefined;
+        this.fullTimeExtent = undefined;
+        this.layout = "auto";
+        this.loop = false;
+        this.mode = "time-window";
+        this.playRate = 1000;
+        this.stops = { count: 10 };
+        this.tickConfigs = undefined;
+        this.timeExtent = undefined;
+        this.timeVisible = false;
+        this.timeZone = undefined;
+        this.position = "bottom-left";
+        this.view = undefined;
+        this.widget = undefined;
+    }
+    referenceElementWatcher(value) {
+        void referenceElementHelper(this, value);
+    }
+    actionsWatcher(value) {
+        if (this.widget) {
+            this.widget.actions = value;
+        }
+    }
+    disabledWatcher(value, old) {
+        if (this.widget && value !== old) {
+            this.widget.disabled = value;
+        }
+    }
+    fullTimeExtentWatcher(value) {
+        if (this.widget) {
+            this.widget.fullTimeExtent = value;
+        }
+    }
+    layoutWatcher(value) {
+        if (this.widget) {
+            this.widget.layout = value;
+        }
+    }
+    loopWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.loop = value;
+        }
+    }
+    modeWatcher(value) {
+        if (this.widget) {
+            this.widget.mode = value;
+        }
+    }
+    playRateWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.playRate = value;
+        }
+    }
+    stopsWatcher(value) {
+        if (this.widget) {
+            this.widget.stops = value;
+        }
+    }
+    tickConfigsWatcher(value) {
+        if (this.widget) {
+            this.widget.tickConfigs = value;
+        }
+    }
+    timeExtentWatcher(value) {
+        if (this.widget) {
+            this.widget.timeExtent = value;
+        }
+    }
+    timeVisibleWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.timeVisible = value;
+        }
+    }
+    timeZoneWatcher(value) {
+        if (this.widget) {
+            this.widget.timeZone = value;
+        }
+    }
+    positionWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.view.ui.move(this.childElem, value);
+        }
+    }
+    viewWatcher(value) {
+        if (value !== undefined && this.widget) {
+            this.widget.view = value;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Methods
+    //
+    //--------------------------------------------------------------------------
+    async next() {
+        this.widget?.next();
+    }
+    async play() {
+        this.widget?.play();
+    }
+    async previous() {
+        this.widget?.previous();
+    }
+    async stop() {
+        this.widget?.stop();
+    }
+    async updateWebDocument(webmap) {
+        this.widget?.updateWebDocument(webmap);
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await newWidgetsTimeSlider(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this._addContainer();
+        this.arcgisTimeSliderReady.emit();
+        checkForView(this);
+    }
+    disconnectedCallback() {
+        onDisconnectedHelper(this);
+    }
+    render() {
+        return h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await importCoreReactiveUtils();
+        addHandles(this, [
+            watch(() => this.widget.effectiveStops, (value) => (this.effectiveStops = value), {
+                initial: true
+            }),
+            watch(() => this.widget.disabled, (value) => (this.disabled = value))
+        ]);
+    }
+    _createParams() {
+        const params = {};
+        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.timeZone) {
+            params.timeZone = this.timeZone;
+        }
+        if (this.view) {
+            params.view = this.view;
+        }
+        return params;
+    }
+    _proxyEvents() {
+        this.widget?.on("trigger-action", (e) => this.timeSliderTriggerAction.emit(e));
+    }
+    get el() { return this; }
+    static get watchers() { return {
+        "referenceElement": ["referenceElementWatcher"],
+        "actions": ["actionsWatcher"],
+        "disabled": ["disabledWatcher"],
+        "fullTimeExtent": ["fullTimeExtentWatcher"],
+        "layout": ["layoutWatcher"],
+        "loop": ["loopWatcher"],
+        "mode": ["modeWatcher"],
+        "playRate": ["playRateWatcher"],
+        "stops": ["stopsWatcher"],
+        "tickConfigs": ["tickConfigsWatcher"],
+        "timeExtent": ["timeExtentWatcher"],
+        "timeVisible": ["timeVisibleWatcher"],
+        "timeZone": ["timeZoneWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return timeSliderCss; }
+}, [0, "arcgis-time-slider", {
+        "referenceElement": [1, "reference-element"],
+        "actions": [16],
+        "disabled": [1540],
+        "effectiveStops": [1040],
+        "fullTimeExtent": [16],
+        "layout": [1],
+        "loop": [4],
+        "mode": [1],
+        "playRate": [2, "play-rate"],
+        "stops": [16],
+        "tickConfigs": [16],
+        "timeExtent": [16],
+        "timeVisible": [4, "time-visible"],
+        "timeZone": [1, "time-zone"],
+        "position": [1],
+        "view": [1040],
+        "widget": [1040],
+        "next": [64],
+        "play": [64],
+        "previous": [64],
+        "stop": [64],
+        "updateWebDocument": [64]
+    }, undefined, {
+        "referenceElement": ["referenceElementWatcher"],
+        "actions": ["actionsWatcher"],
+        "disabled": ["disabledWatcher"],
+        "fullTimeExtent": ["fullTimeExtentWatcher"],
+        "layout": ["layoutWatcher"],
+        "loop": ["loopWatcher"],
+        "mode": ["modeWatcher"],
+        "playRate": ["playRateWatcher"],
+        "stops": ["stopsWatcher"],
+        "tickConfigs": ["tickConfigsWatcher"],
+        "timeExtent": ["timeExtentWatcher"],
+        "timeVisible": ["timeVisibleWatcher"],
+        "timeZone": ["timeZoneWatcher"],
+        "position": ["positionWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement$1() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["arcgis-time-slider"];
+    components.forEach(tagName => { switch (tagName) {
+        case "arcgis-time-slider":
+            if (!customElements.get(tagName)) {
+                customElements.define(tagName, ArcgisTimeSlider$1);
+            }
+            break;
+    } });
+}
+defineCustomElement$1();
+
+const ArcgisTimeSlider = ArcgisTimeSlider$1;
+const defineCustomElement = defineCustomElement$1;
+
+export { ArcgisTimeSlider, defineCustomElement };

package/{components → dist/components}/arcgis-track.d.ts

@@ -2,8 +2,8 @@ import type { Components, JSX } from "../types/components";
 
 interface ArcgisTrack extends Components.ArcgisTrack, HTMLElement {}
 export const ArcgisTrack: {
-  prototype: ArcgisTrack;
-  new (): ArcgisTrack;
+    prototype: ArcgisTrack;
+    new (): ArcgisTrack;
 };
 /**
  * Used to define this component and all nested components recursively.