@esri/solutions-components 0.8.38 → 0.8.40

package/dist/cjs/spatial-ref.cjs.entry.js

@@ -8,10 +8,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff18be0d.js');
-const locale = require('./locale-6973733d.js');
-const common = require('./common-03600219.js');
-require('./esri-loader-fce6a9cb.js');
-require('./solution-resource-ffe3c333.js');
+const locale = require('./locale-f6fd03d2.js');
+const common = require('./common-7ee7ad73.js');
+require('./esri-loader-a56cbcbe.js');
+require('./_commonjsHelpers-baf43783.js');
+require('./solution-resource-a09a6fe0.js');
 require('./index-f64944ad.js');
 require('./interfaces-7cd0a48a.js');
 
@@ -21103,7 +21104,7 @@ const SpatialRef = class {
      * Renders the component.
      */
     render() {
-        return (index.h(index.Host, { key: '0ca21876510da4276c6fd31885eed7dc15db70ad' }, index.h("div", { key: '90ff94d67604a66f20d30276a1b573affccf5eb2' }, index.h("calcite-input", { key: '35e207303270345e457406e26689f58bf5387d43', disabled: this.disabled, id: "calcite-sr-search", onKeyUp: (evt) => this._searchInputKeyDown(evt), placeholder: this._translations.spatialReferencePlaceholder }), index.h("calcite-tree", { key: '0b73019247c134d0cfcdf8e84544622907a40a80', id: "calcite-sr-tree", slot: "children" }, this._getTreeContent()))));
+        return (index.h(index.Host, { key: '23f3f6ff3d7eeeaeb8fb916532302a241fdbc078' }, index.h("div", { key: 'ea7631c0c26d451a72bd68e24ccb3ac757cf73f3' }, index.h("calcite-input", { key: '32d27336b3bc34ee6cd0d3c7ac3e52de7ee8011e', disabled: this.disabled, id: "calcite-sr-search", onKeyUp: (evt) => this._searchInputKeyDown(evt), placeholder: this._translations.spatialReferencePlaceholder }), index.h("calcite-tree", { key: '927f03277a45d5cf256306a2246bccffc0d296cb', id: "calcite-sr-tree", slot: "children" }, this._getTreeContent()))));
     }
     //--------------------------------------------------------------------------
     //

package/dist/cjs/store-manager.cjs.entry.js

@@ -8,6 +8,14 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-ff18be0d.js');
+const solutionStore = require('./solution-store-d9f3ea44.js');
+const templates = require('./templates-f7a3bf48.js');
+require('./index-97020c9d.js');
+require('./interfaces-7cd0a48a.js');
+require('./solution-resource-a09a6fe0.js');
+require('./_commonjsHelpers-baf43783.js');
+require('./index-f64944ad.js');
+require('./restHelpersGet-be451f4a.js');
 
 const StoreManager = class {
     constructor(hostRef) {
@@ -33,26 +41,22 @@ const StoreManager = class {
     }
     /**
      * Initialize the observer that will monitor and respond to changes in the value.
-     * When we get a new value we are dealinmg with a new solution and need to fetch the items data and load the state.
+     * When we get a new value we are dealing with a new solution and need to fetch the item's data and load the state.
      */
     _initValueObserver() {
-        //const self = this;
+        const self = this;
         this._valueObserver = new MutationObserver(ml => {
             ml.some(mutation => {
                 const newValue = mutation.target[mutation.attributeName];
                 if (mutation.type === 'attributes' && mutation.attributeName === "value" &&
                     newValue !== mutation.oldValue && newValue !== "") {
-                    /*
-                    const v = JSON.parse(newValue);
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    getItemDataAsJson(v, self.authentication).then(data => {
-                      state.models = getModels(Array.isArray(v) ? v : [v], self.authentication, v);
-                      state.featureServices = getFeatureServices(Array.isArray(v) ? v : [v])
-                      state.get("spatialReferenceInfo") = getSpatialReferenceInfo(state.featureServices, data);
-                      self.templates = v;
-                      self.stateLoaded.emit(state);
-                    });
-                    */
+                    const solutionData = JSON.parse(newValue);
+                    solutionStore.state.setStoreInfo("solutionData", solutionData);
+                    const services = templates.getFeatureServices(solutionData.templates);
+                    solutionStore.state.setStoreInfo("featureServices", services);
+                    solutionStore.state.setStoreInfo("spatialReferenceInfo", templates.getSpatialReferenceInfo(services, solutionData));
+                    //self.templates = solutionData;
+                    self.stateLoaded.emit(solutionStore.state);
                     return true;
                 }
             });

package/dist/cjs/templates-f7a3bf48.js

@@ -0,0 +1,401 @@
+/*!
+ * Copyright 2022 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+'use strict';
+
+require('./solution-resource-a09a6fe0.js');
+const restHelpersGet = require('./restHelpersGet-be451f4a.js');
+require('./index-f64944ad.js');
+
+/** @license
+ * Copyright 2022 Esri
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//--------------------------------------------------------------------------
+//
+//  Public Functions
+//
+//--------------------------------------------------------------------------
+/**
+ * Gets a list of Feature Services that are not views along with an enabled property that indicates
+ * if the service currently uses a spatial reference variable.
+ *
+ * @param templates a list of item templates from the solution
+ *
+ * @returns a list of feature service names and an enabled property to indicate
+ * if they currently use a spatial reference variable.
+ */
+function getFeatureServices(templates) {
+    return templates.reduce((prev, cur) => {
+        const name = cur.item.title || cur.item.name;
+        if (cur.type === "Feature Service" &&
+            cur.item.typeKeywords.indexOf("View Service") < 0 &&
+            prev.indexOf(name) < 0) {
+            const wkid = restHelpersGet.getProp(cur, "properties.service.spatialReference.wkid");
+            prev.push({ name, enabled: wkid.toString().startsWith("{{params.wkid||") });
+        }
+        return prev;
+    }, []);
+}
+/**
+ * Sort the solution items
+ *
+ * @param templates a list of item templates from the solution
+ *
+ * @returns a sorted list of solution items
+ */
+function getInventoryItems(templates) {
+    const hierarchy = getItemHierarchy(templates);
+    const ids = hierarchy.reduce((prev, cur) => {
+        prev.push(cur.id);
+        return prev;
+    }, []);
+    return templates.reduce((prev, cur) => {
+        if (ids.indexOf(cur.itemId) > -1) {
+            const hierarchyItems = hierarchy.filter(hi => hi.id === cur.itemId);
+            prev.push(_getItemFromTemplate(cur, templates, hierarchyItems[0].dependencies));
+        }
+        return prev;
+    }, []);
+}
+/**
+ * Create item hierarchy that will avoid issues from cylical dependencies
+ *
+ * @param templates a list of item templates from the solution
+ *
+ * @returns a hierarchy for item and item dependency display
+ */
+function getItemHierarchy(templates) {
+    const hierarchy = [];
+    // Get the template specified by id out of a list of templates
+    function getTemplateInSolution(templates, id) {
+        const iTemplate = templates.findIndex((template) => id === template.itemId);
+        return iTemplate >= 0 ? templates[iTemplate] : null;
+    }
+    // Hierarchically list the dependencies of specified node
+    function traceItemId(id, accumulatedHierarchy, alreadyVisitedIds = []) {
+        // Get the dependencies of the node
+        const template = getTemplateInSolution(templates, id);
+        /* istanbul ignore else */
+        if (template) {
+            const templateEntry = {
+                id,
+                dependencies: []
+            };
+            // Visit each dependency, but only if this template is not in the alreadyVisitedIds list to avoid infinite loops
+            /* istanbul ignore else */
+            if (alreadyVisitedIds.indexOf(id) < 0) {
+                // Add dependency to alreadyVisitedIds list
+                alreadyVisitedIds.push(id);
+                template.dependencies.forEach((dependencyId) => {
+                    // Remove dependency from list of templates to visit in the top-level loop
+                    const iDependencyTemplate = templateItemIds.indexOf(dependencyId);
+                    /* istanbul ignore else */
+                    if (iDependencyTemplate >= 0) {
+                        templateItemIds.splice(iDependencyTemplate, 1);
+                    }
+                    traceItemId(dependencyId, templateEntry.dependencies, alreadyVisitedIds);
+                });
+            }
+            accumulatedHierarchy.push(templateEntry);
+        }
+    }
+    // Start with top-level nodes and add in the rest of the nodes to catch cycles without top-level nodes
+    let templateItemIds = _getTopLevelItemIds(templates);
+    const otherItems = templates
+        .filter((template) => templateItemIds.indexOf(template.itemId) < 0) // only keep non-top-level nodes
+        .sort((a, b) => b.dependencies.length - a.dependencies.length); // sort so that nodes with more dependencies come first--reduces stubs
+    templateItemIds = templateItemIds.concat(otherItems.map((template) => template.itemId));
+    // Step through the list of nodes; we'll also remove nodes as we visit them
+    let itemId = templateItemIds.shift();
+    while (typeof itemId !== "undefined") {
+        traceItemId(itemId, hierarchy);
+        itemId = templateItemIds.shift();
+    }
+    return hierarchy;
+}
+/**
+ * Set key organization variables we will allow users to insert at runtime
+ *
+ * @param translations nls translation object
+ *
+ * @returns a list of variables for the organization
+ */
+function getOrganizationVariables(translations) {
+    const orgVars = [{
+            id: "",
+            title: translations.geocodeUrl,
+            value: "{{organization.helperServices.geocode:getDefaultLocatorURL}}"
+        }, {
+            id: "",
+            title: translations.geometryUrl,
+            value: "{{organization.helperServices.geometry.url}}"
+        }, {
+            id: "",
+            title: translations.portalBaseUrl,
+            value: "{{portalBaseUrl}}"
+        }, {
+            id: "",
+            title: translations.routeUrl,
+            value: "{{organization.helperServices.route.url}}"
+        }, {
+            id: "",
+            title: translations.solutionItemExtent,
+            value: "{{solutionItemExtent}}"
+        }];
+    return orgVars;
+}
+/**
+ * Explore the solution item templates for variables we will allow users to insert at runtime
+ *
+ * @param templates a list of item templates from the solution
+ * @param translations nls translation object
+ *
+ * @returns a list of variables from the solution item templates
+ */
+function getSolutionVariables(templates, translations) {
+    const vars = [];
+    templates.forEach(t => {
+        const item = {
+            id: t.itemId,
+            title: t.item.title || t.item.name,
+            type: t.type,
+            value: undefined,
+            dependencies: [{
+                    id: t.itemId,
+                    title: translations.itemId,
+                    value: `{{${t.itemId}.itemId}}`,
+                }]
+        };
+        if (t.item.url) {
+            item.dependencies.push({
+                id: t.itemId,
+                title: translations.url,
+                value: `{{${t.itemId}.url}}`,
+            });
+        }
+        if (t.type === "Feature Service") {
+            // TODO need to set source service name var...
+            // TODO need to set soure service shape field name "{{d05b3cf1ffcb4a4fa677627dfb18609e.name}}.Shape"
+            item.dependencies.push({
+                id: t.itemId,
+                title: translations.solutionExtent,
+                value: `{{${t.itemId}.solutionExtent}}`,
+            });
+            _addLayersOrTables(t.properties.layers || [], item, t, translations);
+            _addLayersOrTables(t.properties.tables || [], item, t, translations);
+        }
+        vars.push(item);
+    });
+    return vars;
+}
+/**
+ * Stores basic spatial reference information that is used to determine if a custom spatial reference parameter will
+ * be exposed while deploying this solution and if so what feature services will support it and what will the default wkid be
+ *
+ * @param services a list of objects with service name and enabled property (indicates if they currently use a spatial reference var)
+ * @param data the data object of a solution item
+ *
+ * @returns an object that stores if a custom spatial reference parameter is enabled/disabled,
+ * a list of services and if they are enabled/disabled, and the default wkid
+ */
+function getSpatialReferenceInfo(services, data) {
+    const defaultServices = {};
+    services.forEach(service => {
+        defaultServices[service.name] = service.enabled;
+    });
+    const wkid = restHelpersGet.getProp(data, "params.wkid.default");
+    return {
+        enabled: wkid !== undefined && wkid !== "",
+        services: defaultServices,
+        spatialReference: wkid ? { wkid } : undefined
+    };
+}
+//--------------------------------------------------------------------------
+//
+//  Private Functions
+//
+//--------------------------------------------------------------------------
+/**
+ * Explore a solution item template for variables we will allow users to insert at runtime.
+ * This function will update the item argument that is passed in with the var details.
+ *
+ * @param children a list of layers or tables from a template
+ * @param item an object that store key details for a given variable
+ * @param template one of the templates from the current solution
+ * @param translations nls translations object
+ *
+ */
+function _addLayersOrTables(children, item, template, translations) {
+    children.forEach(l => {
+        const name = l.name && l.name.indexOf("||") > -1 ? l.name.split("||")[1].replace("}}", "").trim() : l.name;
+        item.dependencies.push({
+            id: template.itemId,
+            title: `${name} (${translations.id})`,
+            value: `{{${template.itemId}.layer${l.id}.id}}`,
+        });
+        item.dependencies.push({
+            id: template.itemId,
+            title: `${name} (${translations.name})`,
+            value: `{{${template.itemId}.layer${l.id}.name||${name}}}`,
+        });
+    });
+}
+/**
+ * Capture key details from the solution item template
+ *
+ * @param template one of the templates from the current solution
+ * @param templates full list of templates
+ * @param dependencies list of hierarchical dependencies
+ *
+ * @returns an IInventoryItem that is used by other components to work with this template
+ */
+function _getItemFromTemplate(template, templates, dependencies) {
+    return {
+        id: template.itemId || "",
+        title: template.item.title || "",
+        dependencies: _getDependencies(dependencies, templates),
+        type: template.item.type || "",
+        typeKeywords: template.item.typeKeywords || [] /*,
+        solutionItem: {
+          itemId: template.itemId,
+          itemDetails: _getItemDetails(template.item, template.type === "Group"),
+          isResource: _getIsResource(template),
+          data: template.data,
+          properties: template.properties,
+          type: template.type,
+          groupDetails: _getGroupDetails(template, templates)
+        }*/
+    };
+}
+/**
+ * Capture key details from the solution item template
+ *
+ * @param dependencies list of dependencies from a template
+ * @param templates full list of templates
+ *
+ * @returns a list of IInventoryItem that are used by other components to work with the templates
+ */
+function _getDependencies(dependencies, templates) {
+    const dependencyItems = [];
+    const depIds = dependencies.reduce((prev, cur) => {
+        prev.push(cur.id);
+        dependencyItems.push(cur);
+        return prev;
+    }, []);
+    return templates.reduce((prev, curr) => {
+        const i = depIds.indexOf(curr.itemId);
+        if (i > -1) {
+            prev.push(_getItemFromTemplate(curr, templates, dependencyItems[i].dependencies));
+        }
+        return prev;
+    }, []);
+}
+/**
+ * Capture the key item details for a given template
+ *
+ * @param item the templates item
+ * @param isGroup boolean to indicate if the item is a group
+ * @param itemId the item id of the template
+ *
+ * @returns a IItemDetails object for the current item
+ */
+/*
+function _getItemDetails(
+  item: any,
+  isGroup: boolean
+): IItemDetails {
+  return {
+    title: item.title || "",
+    snippet: item.snippet || "",
+    description: item.description || "",
+    tags: item.tags || [],
+    accessInformation: !isGroup ? item.accessInformation || "" : "",
+    licenseInfo: !isGroup ? item.licenseInfo || "" : ""
+  };
+}
+*/
+/**
+ * Capture the key item details for a given group template
+ *
+ * @param template one of the templates from the current solution
+ * @param templates full list of templates
+ *
+ * @returns a list of IItemShare objects
+ */
+/*
+function _getGroupDetails(
+  template: any,
+  templates: any[]
+): IItemShare[] {
+  return template.type === "Group" ? templates.reduce((prev, cur) => {
+    if (cur.itemId !== template.itemId && cur.type !== "Group") {
+      prev.push({
+        id: cur.itemId,
+        title: cur.item.name || cur.item.title,
+        isShared: (cur.groups || []).indexOf(template.itemId) > -1,
+        shareItem: (cur.groups || []).indexOf(template.itemId) > -1,
+        type: cur.type,
+        typeKeywords: cur.item.typeKeywords
+      });
+    }
+    return prev;
+  }, []) : [];
+}
+*/
+/**
+ * Used to understand if we are dealing with a binary object that will support upload/download
+ *
+ * @param template one of the templates from the current solution
+ *
+ * @returns true if this item supports upload/download
+ */
+/*
+function _getIsResource(
+  template: any
+): boolean {
+  return template.type !== "Group" && template.resources.some(r => r.indexOf("_info_thumbnail") < 0) &&
+    (template.data === null || JSON.stringify(template.data) === "{}");
+}
+*/
+/**
+ * Sort the template ids based on their dependencies
+ *
+ * @param templates full list of templates
+ *
+ * @returns a list of Itop level item ids
+ */
+function _getTopLevelItemIds(templates) {
+    // Find the top-level nodes. Start with all nodes, then remove those that other nodes depend on
+    const topLevelItemCandidateIds = templates.map((template) => template.itemId);
+    templates.forEach((template) => {
+        (template.dependencies || []).forEach((dependencyId) => {
+            const iNode = topLevelItemCandidateIds.indexOf(dependencyId);
+            if (iNode >= 0) {
+                // Node is somebody's dependency, so remove the node from the list of top-level nodes
+                // If iNode == -1, then it's a shared dependency and it has already been removed
+                topLevelItemCandidateIds.splice(iNode, 1);
+            }
+        });
+    });
+    return topLevelItemCandidateIds;
+}
+
+exports.getFeatureServices = getFeatureServices;
+exports.getInventoryItems = getInventoryItems;
+exports.getOrganizationVariables = getOrganizationVariables;
+exports.getSolutionVariables = getSolutionVariables;
+exports.getSpatialReferenceInfo = getSpatialReferenceInfo;

package/dist/cjs/{utils-1de4eaa0.js → utils-31a22d49.js}

@@ -5,7 +5,7 @@
  */
 'use strict';
 
-const locale = require('./locale-62f4cef2.js');
+const locale = require('./locale-708985a1.js');
 const index = require('./index-97020c9d.js');
 
 exports.EInputType = void 0;

package/dist/collection/components/solution-item/solution-item.js

@@ -50,7 +50,7 @@ export class SolutionItem {
      * Renders the component.
      */
     render() {
-        return (h(Host, { key: '46215591e1f5c87fc30b116fbeeeef5e7eb29b19' }, h("div", { key: 'dbcb49c592eca9f30b44fb3e8a35d0433ed517d3', class: "configuration-container" }, h("div", { key: '9f97e7c2a6a912f3d57d1bc840cab02d13860da2', class: "configuration" }, this._showGroupTabs(this.itemType === "Group"), this._showItemTabs(this.itemType !== "Group")))));
+        return (h(Host, { key: '16de446a44799754d7066eb5cc587585fc9e37c8' }, h("div", { key: 'ddb7c1e6c86657502dc4b293d495f3b4dee594cf', class: "configuration-container" }, h("div", { key: '016954a98a5eb229a1f9eb2a4b9260daff3593bf', class: "configuration" }, this._showGroupTabs(this.itemType === "Group"), this._showItemTabs(this.itemType !== "Group")))));
     }
     //--------------------------------------------------------------------------
     //

package/dist/collection/components/solution-spatial-ref/solution-spatial-ref.css

@@ -42,7 +42,6 @@
 }
 
 .switch-label {
-  margin: 0.25rem;
   font-size: 0.875rem;
   line-height: 1.25rem;
 }
@@ -55,4 +54,15 @@
 .spatial-ref-desc {
   padding-bottom: 0.5rem;
   padding-inline-start: 0.25rem;
+}
+
+.spatial-ref-services-list {
+  margin-block-start: 0.5em;
+  margin-block-end: 0.5em;
+  list-style-type: none;
+  padding-inline-start: 0;
+}
+
+.spatial-ref-services-list-item {
+  margin-top: 0.25rem;
 }