@esri/solutions-components 0.0.2 → 0.0.4

package/dist/esm/templates-c15e0de2.js

@@ -0,0 +1,414 @@
+/*!
+ * Copyright 2021 Esri
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+import { g as getProp, b as blobToText, d as blobToJson } from './generalHelpers-91e92dc0.js';
+import { r as request } from './request-9c2c9a49.js';
+import './editStore-197be454.js';
+
+/**
+ * Gets a Blob from a web site.
+ *
+ * @param url Address of Blob
+ * @param authentication Credentials for the request
+ * @param requestOptions - Options for the request, including parameters relevant to the endpoint.
+ * @return Promise that will resolve with Blob or an AGO-style JSON failure response
+ */
+function getBlob(url, authentication, requestOptions = {}) {
+    if (!url) {
+        return Promise.reject("Url must be provided");
+    }
+    const blobRequestOptions = {
+        authentication: authentication,
+        rawResponse: true,
+        ...requestOptions
+    };
+    return request(url, blobRequestOptions).then(response => {
+        return response.blob();
+    });
+}
+
+/** @license
+ * Copyright 2018 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.
+ */
+// ------------------------------------------------------------------------------------------------------------------ //
+const ZIP_FILE_HEADER_SIGNATURE = "PK";
+/**
+ * Gets a Blob from a web site and checks for a JSON error packet in the Blob.
+ *
+ * @param url Address of Blob
+ * @param authentication Credentials for the request
+ * @param ignoreErrors List of HTTP error codes that should be ignored
+ * @return Promise that will resolve with Blob or an AGO-REST JSON failure response
+ */
+function getBlobCheckForError(url, authentication, ignoreErrors = []) {
+    return new Promise((resolve, reject) => {
+        // Get the blob from the URL
+        getBlob(url, authentication).then(blob => {
+            // Reclassify text/plain blobs as needed
+            _fixTextBlobType(blob).then(adjustedBlob => {
+                if (adjustedBlob.type === "application/json") {
+                    // Blob may be an error
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    blobToJson(adjustedBlob).then((json) => {
+                        // Check for valid JSON with an error
+                        if (json?.error) {
+                            const code = json.error.code;
+                            if (code !== undefined && ignoreErrors.indexOf(code) >= 0) {
+                                resolve(null); // Error, but ignored
+                            }
+                            else {
+                                reject(json); // Other error; fail with error
+                            }
+                        }
+                        else {
+                            resolve(adjustedBlob);
+                        }
+                    });
+                }
+                else {
+                    resolve(adjustedBlob);
+                }
+            }, reject);
+        }, reject);
+    });
+}
+/**
+ * Gets the data information of an AGO item in its JSON form.
+ *
+ * @param itemId Id of an item whose data information is sought
+ * @param filename Name to use for file
+ * @param authentication Credentials for the request to AGO
+ * @return Promise that will resolve with JSON, or an AGO-style JSON failure response
+ */
+function getItemDataAsJson(itemId, authentication) {
+    return new Promise(resolve => {
+        getItemDataBlob(itemId, authentication).then(blob => resolve(blobToJson(blob)), () => resolve(null));
+    });
+}
+/**
+ * Gets the data information of an AGO item in its raw (Blob) form.
+ *
+ * @param itemId Id of an item whose data information is sought
+ * @param authentication Credentials for the request to AGO
+ * @return A promise that will resolve with the data Blob or null if the item doesn't have a data section
+ */
+function getItemDataBlob(itemId, authentication) {
+    return new Promise(resolve => {
+        const url = getItemDataBlobUrl(itemId, authentication);
+        getBlobCheckForError(url, authentication, [400, 500]).then(blob => resolve(_fixTextBlobType(blob)), () => resolve(null));
+    });
+}
+/**
+ * Gets the URL to the data information of an AGO item in its raw (Blob) form.
+ *
+ * @param itemId Id of an item whose data information is sought
+ * @param authentication Credentials for the request to AGO
+ * @return URL string
+ */
+function getItemDataBlobUrl(itemId, authentication) {
+    return `${getPortalSharingUrlFromAuth(authentication)}/content/items/${itemId}/data`;
+}
+/**
+ * Extracts the portal sharing url from a supplied authentication.
+ *
+ * @param authentication Credentials for the request to AGO
+ * @returns Portal sharing url to be used in API requests, defaulting to `https://www.arcgis.com/sharing/rest`
+ */
+function getPortalSharingUrlFromAuth(authentication) {
+    // If auth was passed, use that portal
+    return getProp(authentication, "portal");
+}
+// ------------------------------------------------------------------------------------------------------------------ //
+/**
+ * Fixes the types of Blobs incorrectly typed as text/plain.
+ *
+ * @param blob Blob to check
+ * @return Promise resolving to original Blob, unless it's originally typed as text/plain but is
+ * really JSON, ZIP, or XML
+ * @protected
+ */
+function _fixTextBlobType(blob) {
+    return new Promise((resolve, reject) => {
+        if (blob &&
+            blob.size > 0 &&
+            (blob.type.startsWith("text/plain") ||
+                blob.type.startsWith("application/json"))) {
+            blobToText(blob).then(blobText => {
+                // Convertible to JSON?
+                try {
+                    JSON.parse(blobText);
+                    // Yes; reclassify as JSON
+                    resolve(new Blob([blob], { type: "application/json" }));
+                }
+                catch (ignored) {
+                    // Nope; test for ZIP file
+                    if (blobText.length > 4 &&
+                        blobText.substr(0, 4) === ZIP_FILE_HEADER_SIGNATURE) {
+                        // Yes; reclassify as ZIP
+                        resolve(new Blob([blob], { type: "application/zip" }));
+                    }
+                    else if (blobText.startsWith("<")) {
+                        // Reclassify as XML; since the blob started out as text/plain, it's more likely that is
+                        // meant to be human-readable, so we'll use text/xml instead of application/xml
+                        resolve(new Blob([blob], { type: "text/xml" }));
+                    }
+                    else {
+                        // Leave as text
+                        resolve(blob);
+                    }
+                }
+            }, 
+            // Faulty blob
+            reject);
+        }
+        else {
+            // Empty or not typed as plain text, so simply return
+            if (blob) {
+                resolve(blob);
+            }
+            else {
+                reject();
+            }
+        }
+    });
+}
+
+/** @license
+ * Copyright 2021 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.
+ */
+function getInventoryItems(templates) {
+  const topLevelItemIds = _getTopLevelItemIds(templates);
+  return templates.reduce((prev, cur) => {
+    if (topLevelItemIds.indexOf(cur.itemId) > -1) {
+      prev.push(_getItemFromTemplate(cur, templates));
+    }
+    return prev;
+  }, []);
+}
+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;
+}
+function _addLayersOrTables(children, item, t, translations) {
+  children.forEach(l => {
+    const name = l.name && l.name.indexOf("||") > -1 ? l.name.split("||")[1].replace("}}", "").trim() : l.name;
+    item.dependencies.push({
+      id: t.itemId,
+      title: `${name} (${translations.id})`,
+      value: `{{${t.itemId}.layer${l.id}.id}}`,
+    });
+    item.dependencies.push({
+      id: t.itemId,
+      title: `${name} (${translations.name})`,
+      value: `{{${t.itemId}.layer${l.id}.name||${name}}}`,
+    });
+  });
+}
+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;
+}
+function getModels(templates) {
+  const ids = [];
+  const models = {};
+  const monacoDefined = typeof (monaco) !== "undefined";
+  templates.forEach(t => {
+    var _a, _b, _c, _d;
+    if (ids.indexOf(t.itemId) < 0) {
+      ids.push(t.itemId);
+      models[t.itemId] = {
+        dataModel: monacoDefined ? monaco.editor.createModel(JSON.stringify(t.data, null, '\t'), "json") : undefined,
+        dataOriginValue: JSON.stringify(t.data),
+        propsModel: monacoDefined ? monaco.editor.createModel(JSON.stringify(t.properties, null, '\t'), "json") : undefined,
+        propsOriginValue: JSON.stringify(t.properties),
+        propsDiffOriginValue: JSON.stringify(t.properties),
+        state: undefined,
+        shareInfo: undefined,
+        isEditing: false,
+        itemId: t.itemId,
+        updateItemValues: {},
+        originalItemValues: {},
+        name: (_a = t.item) === null || _a === void 0 ? void 0 : _a.name,
+        title: (_b = t.item) === null || _b === void 0 ? void 0 : _b.title,
+        itemOriginValue: JSON.stringify(t.item),
+        spatialReference: (_d = (_c = t.properties) === null || _c === void 0 ? void 0 : _c.service) === null || _d === void 0 ? void 0 : _d.spatialReference
+      };
+    }
+  });
+  return models;
+}
+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 = getProp(cur, "properties.service.spatialReference.wkid");
+      prev.push({ name, enabled: wkid.toString().startsWith("{{params.wkid||") });
+    }
+    return prev;
+  }, []);
+}
+function getSpatialReferenceInfo(services, data) {
+  const defaultServices = {};
+  services.forEach(service => {
+    defaultServices[service.name] = service.enabled;
+  });
+  const wkid = getProp(data, "params.wkid.default");
+  return {
+    enabled: wkid !== undefined && wkid !== "",
+    services: defaultServices,
+    spatialReference: wkid ? { wkid } : undefined
+  };
+}
+function _getItemFromTemplate(t, templates) {
+  return {
+    id: t.itemId || "",
+    title: t.item.title || "",
+    dependencies: _getDependencies(t.dependencies || [], templates),
+    type: t.item.type || "",
+    typeKeywords: t.item.typeKeywords || [],
+    solutionItem: {
+      itemId: t.itemId,
+      itemDetails: _getItemDetails(t.item, t.type === "Group", t.itemId),
+      isResource: _getIsResource(t),
+      data: t.data,
+      properties: t.properties,
+      type: t.type,
+      groupDetails: _getGroupDetails(t, templates)
+    }
+  };
+}
+function _getDependencies(dependencies, templates) {
+  return templates.reduce((prev, curr) => {
+    if (dependencies.indexOf(curr.itemId) > -1) {
+      prev.push(_getItemFromTemplate(curr, templates));
+    }
+    return prev;
+  }, []);
+}
+function _getItemDetails(item, isGroup, itemId) {
+  return {
+    itemId,
+    thumbnail: item.thumbnail || "",
+    title: item.title || "",
+    snippet: item.snippet || "",
+    description: item.description || "",
+    tags: item.tags || [],
+    accessInformation: !isGroup ? item.accessInformation || "" : "",
+    licenseInfo: !isGroup ? item.licenseInfo || "" : ""
+  };
+}
+function _getGroupDetails(t, templates) {
+  return t.type === "Group" ? templates.reduce((prev, cur) => {
+    if (cur.itemId !== t.itemId && cur.type !== "Group") {
+      prev.push({
+        id: cur.itemId,
+        title: cur.item.name || cur.item.title,
+        isShared: (cur.groups || []).indexOf(t.itemId) > -1,
+        shareItem: (cur.groups || []).indexOf(t.itemId) > -1,
+        type: cur.type,
+        typeKeywords: cur.item.typeKeywords
+      });
+    }
+    return prev;
+  }, []) : [];
+}
+function _getIsResource(template) {
+  return template.type !== "Group" && JSON.stringify(template.data) === "{}";
+}
+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;
+}
+
+export { getModels as a, getFeatureServices as b, getSpatialReferenceInfo as c, getInventoryItems as d, getSolutionVariables as e, getOrganizationVariables as f, getItemDataAsJson as g };

package/dist/esm/time-a3b29c35.js

@@ -65,5 +65,3 @@ function formatTimePart(number) {
 }
 
 export { getMeridiem as a, formatTimePart as b, formatTimeString as f, getMeridiemHour as g, maxTenthForMinuteAndSecond as m, parseTimeString as p };
-
-//# sourceMappingURL=time-a3b29c35.js.map

package/dist/esm/utils-021cb956.js

@@ -41,5 +41,3 @@ function getDepth(element) {
 }
 
 export { ComboboxChildSelector as C, getItemChildren as a, ComboboxItem as b, ComboboxItemGroup as c, ComboboxDefaultPlacement as d, getAncestors as e, getDepth as f, getItemAncestors as g, hasActiveChildren as h };
-
-//# sourceMappingURL=utils-021cb956.js.map

package/dist/esm/utils-5fdd203c.js

@@ -116,5 +116,3 @@ function colorEqual(value1, value2) {
 }
 
 export { CSSColorMode as C, isLonghandHex as a, hexChar as b, colorEqual as c, hexToRGB as h, isValidHex as i, normalizeHex as n, parseMode as p, rgbToHex as r };
-
-//# sourceMappingURL=utils-5fdd203c.js.map

package/dist/solutions/assets/nls/fr/strings.js

@@ -34,6 +34,7 @@ define({
       "diff": "fr-Toggle Diff Editor",
       "download": "Télécharger",
       "editThumbnail": "Mettre à jour la miniature",
+      "editsSaved": "fr-Edits Saved Successfully",
       "featureServicesHeading": "Services de fonctionnalités",
       "geocodeUrl": "fr-Geocode URL",
       "geometryUrl": "fr-Geometry URL",
@@ -49,6 +50,7 @@ define({
       "routeUrl": "fr-Route URL",
       "redo": "fr-Redo",
       "saveEdits": "fr-Save Edits",
+      "saveFailed": "fr-Save Edits Failed",
       "search": "Chercher",
       "sharingTab": "Partage",
       "snippetCountPattern": "{{n}} sur 250",

package/dist/solutions/assets/nls/strings.js

@@ -36,6 +36,7 @@ define({
         "diff": "Toggle Diff Editor",
         "download": "Download",
         "editThumbnail": "Edit Thumbnail",
+        "editsSaved": "Edits Saved Successfully",
         "featureServicesHeading": "Feature Services",
         "geocodeUrl": "Geocode URL",
         "geometryUrl": "Geometry URL",
@@ -51,6 +52,7 @@ define({
         "routeUrl": "Route URL",
         "redo": "Redo",
         "saveEdits": "Save Edits",
+        "saveFailed": "Save Edits Failed",
         "search": "Search",
         "sharingTab": "Sharing",
         "snippetCountPattern": "{{n}} of 250",