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

package/dist/cjs/arcgis-slider.cjs.entry.js

@@ -0,0 +1,234 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-a4132fa9.js');
+const index$1 = require('./index-653a4c1d.js');
+const componentUtils = require('./component-utils-e131f0db.js');
+const disconnected = require('./disconnected-ee64795e.js');
+
+const sliderCss = "arcgis-slider{min-width:200px;min-height:25px}";
+
+const ArcgisSlider = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.sliderMaxChange = index.createEvent(this, "sliderMaxChange", 7);
+        this.sliderMaxClick = index.createEvent(this, "sliderMaxClick", 7);
+        this.sliderMinChange = index.createEvent(this, "sliderMinChange", 7);
+        this.sliderMinClick = index.createEvent(this, "sliderMinClick", 7);
+        this.sliderSegmentClick = index.createEvent(this, "sliderSegmentClick", 7);
+        this.sliderSegmentDrag = index.createEvent(this, "sliderSegmentDrag", 7);
+        this.sliderThumbChange = index.createEvent(this, "sliderThumbChange", 7);
+        this.sliderThumbClick = index.createEvent(this, "sliderThumbClick", 7);
+        this.sliderThumbDrag = index.createEvent(this, "sliderThumbDrag", 7);
+        this.sliderTickClick = index.createEvent(this, "sliderTickClick", 7);
+        this.sliderTrackClick = index.createEvent(this, "sliderTrackClick", 7);
+        this.widgetReady = index.createEvent(this, "widgetReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.draggableSegmentsEnabled = undefined;
+        this.effectiveMax = undefined;
+        this.effectiveMin = undefined;
+        this.effectiveSegmentElements = undefined;
+        this.labelElements = undefined;
+        this.labelInputsEnabled = undefined;
+        this.labels = undefined;
+        this.layout = "horizontal";
+        this.min = undefined;
+        this.max = undefined;
+        this.maxLabelElement = undefined;
+        this.minLabelElement = undefined;
+        this.precision = undefined;
+        this.rangeLabelInputsEnabled = undefined;
+        this.segmentElements = undefined;
+        this.snapOnClickEnabled = undefined;
+        this.syncedSegmentsEnabled = undefined;
+        this.thumbElements = undefined;
+        this.thumbsConstrained = undefined;
+        this.tickConfigs = undefined;
+        this.tickElements = undefined;
+        this.trackElement = undefined;
+        this.steps = undefined;
+        this.values = undefined;
+        this.position = "bottom-left";
+        this.expandable = false;
+        this.widget = undefined;
+    }
+    draggableSegmentsEnabledWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.draggableSegmentsEnabled = newValue;
+        }
+    }
+    effectiveMaxWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.effectiveMax = newValue;
+        }
+    }
+    effectiveMinWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.effectiveMin = newValue;
+        }
+    }
+    layoutWatcher(newValue) {
+        if (this.widget) {
+            this.widget.layout = newValue;
+        }
+    }
+    minWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.min = newValue;
+        }
+    }
+    maxWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.max = newValue;
+        }
+    }
+    precisionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.precision = newValue;
+        }
+    }
+    rangeLabelInputsEnabledWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.rangeLabelInputsEnabled = newValue;
+        }
+    }
+    snapOnClickEnabledWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.snapOnClickEnabled = newValue;
+        }
+    }
+    syncedSegmentsEnabledWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.syncedSegmentsEnabled = newValue;
+        }
+    }
+    thumbsConstrainedWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.thumbsConstrained = newValue;
+        }
+    }
+    tickConfigsWatcher(newValue) {
+        if (this.widget) {
+            this.widget.tickConfigs = newValue;
+        }
+    }
+    stepsWatcher(newValue) {
+        if (this.widget) {
+            this.widget.steps = newValue;
+        }
+    }
+    valuesWatcher(newValue) {
+        if (typeof newValue === "string") {
+            this.values = newValue.split(",").map((n) => Number(n));
+        }
+        if (this.widget) {
+            this.widget.values = this.values;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await index$1.newWidgetsSlider(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this.widgetReady.emit({ widget: this.widget });
+        componentUtils.checkForView(this);
+    }
+    disconnectedCallback() {
+        disconnected.onDisconnectedHelper(this);
+    }
+    render() {
+        if (this.expandable) {
+            return (index.h("arcgis-expand", { position: this.position, ref: (el) => (this.expandElem = el) }, index.h("div", { ref: (el) => (this.childElem = el) })));
+        }
+        return index.h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    async _addWatchers() {
+        const { watch } = await index$1.importCoreReactiveUtils();
+        componentUtils.addHandles(this, watch(() => this.widget.effectiveSegmentElements, (value) => (this.effectiveSegmentElements = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.labelElements, (value) => (this.labelElements = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.maxLabelElement, (value) => (this.maxLabelElement = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.minLabelElement, (value) => (this.minLabelElement = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.segmentElements, (value) => (this.segmentElements = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.thumbElements, (value) => (this.thumbElements = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.tickElements, (value) => (this.tickElements = value), {
+            initial: true
+        }));
+        componentUtils.addHandles(this, watch(() => this.widget.trackElement, (value) => (this.trackElement = value), {
+            initial: true
+        }));
+    }
+    _createParams() {
+        const params = {
+            container: this.childElem,
+            layout: this.layout
+        };
+        if (this.min !== undefined) {
+            params.min = this.min;
+        }
+        if (this.max !== undefined) {
+            params.max = this.max;
+        }
+        if (this.steps) {
+            if (typeof this.steps === "string") {
+                this.steps = this.steps.split(",").map((n) => Number(n));
+            }
+            params.steps = this.steps;
+        }
+        if (this.values) {
+            if (typeof this.values === "string") {
+                this.values = this.values.split(",").map((n) => Number(n));
+            }
+            params.values = this.values;
+        }
+        return params;
+    }
+    get el() { return index.getElement(this); }
+    static get watchers() { return {
+        "draggableSegmentsEnabled": ["draggableSegmentsEnabledWatcher"],
+        "effectiveMax": ["effectiveMaxWatcher"],
+        "effectiveMin": ["effectiveMinWatcher"],
+        "layout": ["layoutWatcher"],
+        "min": ["minWatcher"],
+        "max": ["maxWatcher"],
+        "precision": ["precisionWatcher"],
+        "rangeLabelInputsEnabled": ["rangeLabelInputsEnabledWatcher"],
+        "snapOnClickEnabled": ["snapOnClickEnabledWatcher"],
+        "syncedSegmentsEnabled": ["syncedSegmentsEnabledWatcher"],
+        "thumbsConstrained": ["thumbsConstrainedWatcher"],
+        "tickConfigs": ["tickConfigsWatcher"],
+        "steps": ["stepsWatcher"],
+        "values": ["valuesWatcher"]
+    }; }
+};
+ArcgisSlider.style = sliderCss;
+
+exports.arcgis_slider = ArcgisSlider;

package/dist/cjs/arcgis-swipe.cjs.entry.js

@@ -0,0 +1,123 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-a4132fa9.js');
+const index$1 = require('./index-653a4c1d.js');
+const componentUtils = require('./component-utils-e131f0db.js');
+const disconnected = require('./disconnected-ee64795e.js');
+
+const swipeCss = "arcgis-swipe{}";
+
+const ArcgisSwipe = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.widgetReady = index.createEvent(this, "widgetReady", 7);
+        this._watchHandles = [];
+        this.referenceElement = undefined;
+        this.direction = undefined;
+        this.dragLabel = undefined;
+        this.leadingLayers = undefined;
+        this.swipePosition = undefined;
+        this.trailingLayers = undefined;
+        this.view = undefined;
+        this.position = "bottom-left";
+        this.widget = undefined;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Watchers
+    //
+    //--------------------------------------------------------------------------
+    directionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.direction = newValue;
+        }
+    }
+    dragLabelWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.dragLabel = newValue;
+        }
+    }
+    leadingLayersWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.leadingLayers = newValue;
+        }
+    }
+    swipePositionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.position = newValue;
+        }
+    }
+    trailingLayersWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.trailingLayers = newValue;
+        }
+    }
+    positionWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            if (typeof this.view !== "string") {
+                this.view.ui.move(this.childElem, newValue);
+            }
+        }
+    }
+    referenceElementWatcher(newValue) {
+        componentUtils.referenceElementHelper(this, newValue);
+    }
+    viewWatcher(newValue) {
+        if (newValue !== undefined && this.widget) {
+            this.widget.view = newValue;
+        }
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    async componentDidLoad() {
+        const params = this._createParams();
+        const widget = await index$1.newWidgetsSwipe(params);
+        this.widget = widget;
+        this.widgetReady.emit({ widget: this.widget });
+        componentUtils.checkForView(this);
+    }
+    disconnectedCallback() {
+        disconnected.onDisconnectedHelper(this);
+    }
+    render() {
+        return index.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 index.getElement(this); }
+    static get watchers() { return {
+        "direction": ["directionWatcher"],
+        "dragLabel": ["dragLabelWatcher"],
+        "leadingLayers": ["leadingLayersWatcher"],
+        "swipePosition": ["swipePositionWatcher"],
+        "trailingLayers": ["trailingLayersWatcher"],
+        "position": ["positionWatcher"],
+        "referenceElement": ["referenceElementWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+};
+ArcgisSwipe.style = swipeCss;
+
+exports.arcgis_swipe = ArcgisSwipe;

package/dist/cjs/arcgis-table-list.cjs.entry.js

@@ -0,0 +1,283 @@
+/*!
+ * All material copyright Esri, All Rights Reserved, unless otherwise specified.
+ * See https://js.arcgis.com/4.29/esri/copyright.txt for details.
+ * v4.29.1
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-a4132fa9.js');
+const index$1 = require('./index-653a4c1d.js');
+const componentUtils = require('./component-utils-e131f0db.js');
+const disconnected = require('./disconnected-ee64795e.js');
+
+const tableListCss = "arcgis-table-list{}";
+
+const ArcgisTableList = class {
+    constructor(hostRef) {
+        index.registerInstance(this, hostRef);
+        this.arcgisTableListReady = index.createEvent(this, "arcgisTableListReady", 7);
+        this.tableListTriggerAction = index.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 componentUtils.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 index$1.newWidgetsTableList(params);
+        this.widget = widget;
+        await this._addWatchers();
+        this._proxyEvents();
+        this._addContainer();
+        this.arcgisTableListReady.emit();
+        componentUtils.checkForView(this);
+    }
+    disconnectedCallback() {
+        disconnected.onDisconnectedHelper(this);
+    }
+    render() {
+        return index.h("div", { ref: (el) => (this.childElem = el) });
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //--------------------------------------------------------------------------
+    _addContainer() {
+        this.widget.container = this.childElem;
+    }
+    async _addWatchers() {
+        const { watch } = await index$1.importCoreReactiveUtils();
+        componentUtils.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 index.getElement(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"]
+    }; }
+};
+ArcgisTableList.style = tableListCss;
+
+exports.arcgis_table_list = ArcgisTableList;