@esri/solutions-components 0.6.8 → 0.6.9

package/dist/collection/utils/downloadUtils.js

@@ -26,7 +26,31 @@ import { queryFeaturesByID } from "./queryUtils";
 export { ILabel } from "./pdfUtils";
 const lineSeparatorChar = "|";
 //#endregion
+// ------------------------------------------------------------------------------------------------------------------ //
 //#region Public functions
+/**
+ * Create and consolidate labels from all layers
+ *
+ * @param exportInfos Key details about what to export (ids, layer, and selectionSetNames)
+ * @param formatUsingLayerPopup When true, the layer's popup is used to choose attributes for each column; when false,
+ * all attributes are exported
+ * @param includeHeaderNames Add the label format at the front of the list of generated labels
+ * @returns selectionSetNames that will be used for export filenames
+ */
+export async function consolidateLabels(exportInfos, formatUsingLayerPopup = true, includeHeaderNames = false, isCSVExport = false) {
+  const labelRequests = [];
+  Object.keys(exportInfos).forEach(k => {
+    var _a;
+    const labelInfo = exportInfos[k];
+    labelRequests.push(_prepareLabels(((_a = labelInfo.layerView) === null || _a === void 0 ? void 0 : _a.layer) || labelInfo.layer, labelInfo.ids, formatUsingLayerPopup, includeHeaderNames));
+    if (isCSVExport) {
+      // add the layer id as a temp value separator that we can use to split values for CSV export
+      labelRequests.push(Promise.resolve([[k]]));
+    }
+  });
+  const labels = await Promise.all(labelRequests);
+  return labels.reduce((prev, cur) => prev.concat(cur), []);
+}
 /**
  * Downloads csv of mailing labels for the provided list of ids
  *
@@ -79,14 +103,62 @@ export async function downloadPDF(exportInfos, labelPageDescription, removeDupli
   exportPDF(_createFilename(selectionSetNames), labels, labelPageDescription, title, initialImageDataUrl);
   return Promise.resolve();
 }
+/**
+ * Remove any duplicate labels
+ *
+ * @param labels Labels to evaluate for duplicates
+ * @returns labels with duplicates removed
+ */
+export function removeDuplicateLabels(labels) {
+  const labelsAsStrings = labels.map(label => JSON.stringify(label));
+  const uniqueLabels = new Set(labelsAsStrings);
+  return Array.from(uniqueLabels, labelString => JSON.parse(labelString));
+}
 //#endregion
+// ------------------------------------------------------------------------------------------------------------------ //
 //#region Private functions
+/**
+ * Converts the text of a custom popup into a multiline label specification; conversion splits text into
+ * lines on <br>s, and removes HTML tags.
+ *
+ * @param labelText Layer's popup text, e.g.,
+ * "<div style='text-align: left;'>{NAME}<br />{STREET}<br />{CITY}, {STATE} {ZIP} <br /></div>"
+ * @return Cleaned-up popup text with lines separated by `lineSeparatorChar`
+ */
+export function _cleanupLabel(labelText) {
+  // Replace <br> variants with the line separator character
+  labelText = labelText.replace(/<br\s*\/?>/gi, lineSeparatorChar);
+  // Replace <p> variants with the line separator character, except in the first position
+  labelText = labelText.replace(/<p[^>]*>/gi, lineSeparatorChar).trim().replace(/^\|/, "");
+  // Remove </p>
+  labelText = labelText.replace(/<\/p>/gi, "");
+  // Replace \n with the line separator character
+  labelText = labelText.replace(/\n/gi, "|");
+  // Remove remaining HTML tags, replace 0xA0 that popup uses for spaces, and replace some char representations
+  labelText = labelText
+    .replace(/<[\s.]*[^<>]*\/?>/gi, "")
+    .replace(/\xA0/gi, " ")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&nbsp;/gi, " ");
+  // Trim each line
+  labelText = labelText.replace(/\s*\|\s*/g, "|");
+  // Remove empty lines
+  while (labelText.match(/\|\|/)) {
+    labelText = labelText.replace(/\|\|/, "|");
+  }
+  // Remove leading and trailing line feeds
+  labelText = labelText.replace(/^\|/, "");
+  labelText = labelText.replace(/\|$/, "");
+  return labelText;
+}
+;
 /**
  * Converts a set of fieldInfos into template lines.
  *
  * @param fieldInfos Layer's fieldInfos structure
  * @param bypassFieldVisiblity Indicates if the configured fieldInfo visibility property should be ignored
- * @return Label spec with lines separated by `lineSeparatorChar`
+ * @return "pattern" label spec with lines separated by `lineSeparatorChar`
  */
 export function _convertPopupFieldsToLabelSpec(fieldInfos, bypassFieldVisiblity = false) {
   const labelSpec = [];
@@ -96,66 +168,35 @@ export function _convertPopupFieldsToLabelSpec(fieldInfos, bypassFieldVisiblity
       labelSpec.push(`{${fieldInfo.fieldName}}`);
     }
   });
-  return labelSpec.join(lineSeparatorChar);
+  return {
+    type: "pattern",
+    format: labelSpec.join(lineSeparatorChar)
+  };
 }
 ;
 /**
  * Converts the text of a custom popup into a multiline label specification; conversion splits text into
  * lines on <br>s, and removes HTML tags. It does not handle Arcade and related records.
  *
- * @param popupInfo Layer's popupInfo structure containing description, fieldInfos, and expressionInfos, e.g.,
+ * @param labelText Layer's labelText structure containing description, fieldInfos, and expressionInfos, e.g.,
  * "<div style='text-align: left;'>{NAME}<br />{STREET}<br />{CITY}, {STATE} {ZIP} <br /></div>"
- * @return Label spec with lines separated by `lineSeparatorChar`
+ * @return "pattern" label spec with lines separated by `lineSeparatorChar`
  */
 export function _convertPopupTextToLabelSpec(popupInfo) {
-  // Replace <br> variants with the line separator character
-  popupInfo = popupInfo.replace(/<br\s*\/?>/gi, lineSeparatorChar);
-  // Replace <p> variants with the line separator character, except in the first position
-  popupInfo = popupInfo.replace(/<p[^>]*>/gi, lineSeparatorChar).trim().replace(/^\|/, "");
-  // Remove </p>
-  popupInfo = popupInfo.replace(/<\/p>/gi, "");
-  // Replace \n with the line separator character
-  popupInfo = popupInfo.replace(/\n/gi, "|");
-  // Remove remaining HTML tags, replace 0xA0 that popup uses for spaces, and replace some char representations
-  let labelSpec = popupInfo
-    .replace(/<[\s.]*[^<>]*\/?>/gi, "")
-    .replace(/\xA0/gi, " ")
-    .replace(/&lt;/gi, "<")
-    .replace(/&gt;/gi, ">")
-    .replace(/&nbsp;/gi, " ");
-  // Trim each line
-  labelSpec = labelSpec.replace(/\s*\|\s*/g, "|");
-  // Remove empty lines
-  while (labelSpec.match(/\|\|/)) {
-    labelSpec = labelSpec.replace(/\|\|/, "|");
-  }
-  // Remove leading and trailing line feeds
-  labelSpec = labelSpec.replace(/^\|/, "");
-  labelSpec = labelSpec.replace(/\|$/, "");
-  return labelSpec.trim();
+  return {
+    type: "pattern",
+    format: _cleanupLabel(popupInfo)
+  };
 }
 ;
 /**
- * Extracts Arcade expressions from the lines of a label format and creates an Arcade executor for each
- * referenced expression name.
+ * Converts an Arcade expression of a custom popup into a multiline label specification.
  *
- * @param labelFormat Label to examine
- * @param layer Layer from which to fetch features
- * @return Promise resolving to a set of executors keyed using the expression name
+ * @param expressionInfo Structure containing expression and info about it
+ * @return Promise resolving to an "executor" label spec
  */
-async function _createArcadeExecutors(labelFormat, layer) {
-  const arcadeExecutors = {};
-  // Are any Arcade expressions in the layer?
-  if (!Array.isArray(layer.popupTemplate.expressionInfos) || layer.popupTemplate.expressionInfos.length === 0) {
-    return Promise.resolve(arcadeExecutors);
-  }
-  // Are there any Arcade expressions in the label format?
-  const arcadeExpressionRegExp = /\{expression\/\w+\}/g;
-  const arcadeExpressionsMatches = labelFormat.match(arcadeExpressionRegExp);
-  if (!arcadeExpressionsMatches) {
-    return Promise.resolve(arcadeExecutors);
-  }
-  // Generate an Arcade executor for each match
+export async function _convertPopupArcadeToLabelSpec(expressionInfo) {
+  // Generate an Arcade executor
   const [arcade] = await loadModules(["esri/arcade"]);
   const labelingProfile = {
     variables: [
@@ -177,24 +218,10 @@ async function _createArcadeExecutors(labelFormat, layer) {
       }
     ]
   };
-  const createArcadeExecutorPromises = {};
-  arcadeExpressionsMatches.forEach((match) => {
-    const expressionName = match.substring(match.indexOf("/") + 1, match.length - 1);
-    (layer.popupTemplate.expressionInfos || []).forEach(expressionInfo => {
-      if (expressionInfo.name === expressionName) {
-        createArcadeExecutorPromises[expressionName] =
-          arcade.createArcadeExecutor(expressionInfo.expression, labelingProfile);
-      }
-    });
-  });
-  const promises = Object.values(createArcadeExecutorPromises);
-  return Promise.all(promises)
-    .then(executors => {
-    const expressionNames = Object.keys(createArcadeExecutorPromises);
-    for (let i = 0; i < expressionNames.length; ++i) {
-      arcadeExecutors[expressionNames[i]] = executors[i].valueOf();
-    }
-    return arcadeExecutors;
+  const executor = await arcade.createArcadeExecutor(expressionInfo.expression, labelingProfile);
+  return Promise.resolve({
+    type: "executor",
+    format: executor
   });
 }
 /**
@@ -258,7 +285,7 @@ export function _getExpressionsFromLabel(labelFormat) {
  * @param labelFormat Label to examine
  * @returns Array of field name expressions, e.g., ["{NAME}", "{STREET}", "{CITY}", "{STATE}", "{ZIP}"]
  */
-export function _getFieldsFromLabel(labelFormat) {
+export function _getFieldExpressionsFromLabel(labelFormat) {
   // Get all fields
   const fieldExpressions = [];
   let iStart = 0;
@@ -280,6 +307,81 @@ export function _getFieldsFromLabel(labelFormat) {
   // Remove the Arcade expressions from the returned list of field expressions
   return fieldExpressions.filter(fieldExpression => arcadeExpressions.indexOf(fieldExpression) < 0);
 }
+/**
+ * Extracts field names from field name expressions.
+ *
+ * @param fieldExpressions Array of field name expressions, e.g., ["{NAME}", "{STREET}", "{CITY}", "{STATE}", "{ZIP}"]
+ * @returns Array of field names, e.g., ["NAME", "STREET", "CITY", "STATE", "ZIP"]
+ */
+export function _getFieldNamesFromFieldExpressions(fieldExpressions) {
+  return fieldExpressions.map(expr => expr.substring(1, expr.length - 1));
+}
+/**
+ * Extracts the label format from the layer.
+ *
+ * @param layer Layer with label format
+ * @param formatUsingLayerPopup When true, the layer's popup is used to choose attributes for each column; when false,
+ * all attributes are exported
+ * @param attributeFormats Empty object to hold the formats for each attribute in a feature; the object is filled
+ * with formats by this function
+ * @returns A Promise resolving to the format of a single label, e.g., for ILabelFormat type "pattern":
+ * "{NAME}|{STREET}|{CITY}, {STATE} {ZIP}"
+ */
+export async function _getLabelFormat(layer, formatUsingLayerPopup, attributeFormats) {
+  var _a, _b, _c, _d, _e, _f;
+  let labelFormat = {
+    type: "unsupported",
+    format: undefined
+  };
+  if (layer.popupEnabled) {
+    layer.popupTemplate.fieldInfos.forEach(
+    // Extract any format info that we have
+    fieldInfo => {
+      if (fieldInfo.format) {
+        attributeFormats[fieldInfo.fieldName] = fieldInfo.format;
+      }
+    });
+    // What is the nature of the label content?
+    // Fields list
+    if (formatUsingLayerPopup && ((_b = (_a = layer.popupTemplate) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.type) === "fields") {
+      labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos);
+      // If popup is configured with "no attribute information", then no fields will visible
+      if (labelFormat.format.length === 0) {
+        // Can we use the popup title?
+        labelFormat = layer.popupTemplate.title && typeof layer.popupTemplate.title === "string" ?
+          { type: "pattern", format: layer.popupTemplate.title }
+          :
+            // Otherwise revert to using attributes
+            _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos, true);
+      }
+      // Example text: '<p>{name} {age} years &nbsp;</p><p>started: {start}</p>'
+    }
+    else if (formatUsingLayerPopup && ((_d = (_c = layer.popupTemplate) === null || _c === void 0 ? void 0 : _c.content[0]) === null || _d === void 0 ? void 0 : _d.type) === "text") {
+      labelFormat = _convertPopupTextToLabelSpec(layer.popupTemplate.content[0].text);
+      // Example expression: 'var feat = $feature\nvar label = `\n\t${feat["name"]} ${feat["age"]} years <br>\n\tstarted: ${feat["start"]}\n`\n\nreturn { \n  type : \'text\', \n  text : label\n}',
+    }
+    else if (formatUsingLayerPopup && ((_f = (_e = layer.popupTemplate) === null || _e === void 0 ? void 0 : _e.content[0]) === null || _f === void 0 ? void 0 : _f.type) === "expression") {
+      labelFormat = await _convertPopupArcadeToLabelSpec(layer.popupTemplate.content[0].expressionInfo);
+    }
+  }
+  return Promise.resolve(labelFormat);
+}
+/**
+ * Extract selectionSetNames from the provided exportInfos
+ *
+ * @param exportInfos Key details about what to export (ids, layer, and selectionSetNames)
+ * @returns selectionSetNames that will be used for export filenames
+ */
+export function _getSelectionSetNames(exportInfos, id = /.+/) {
+  let selectionSetNames = [];
+  Object.keys(exportInfos).forEach(k => {
+    const exportInfo = exportInfos[k];
+    if (id.test(k)) {
+      selectionSetNames = selectionSetNames.concat(exportInfo.selectionSetNames);
+    }
+  });
+  return selectionSetNames;
+}
 /**
  * Prepares an attribute's value by applying domain and type information.
  *
@@ -288,13 +390,16 @@ export function _getFieldsFromLabel(labelFormat) {
  * @param attributeDomain Domain info for attribute, if any
  * @param attributeFormat Format info for attribute, if any
  * @param intl esri/intl
- * @return Attribute value modified appropriate to domain and type
+ * @return Attribute value modified appropriate to domain and type and converted to a string
  */
-function _prepareAttributeValue(attributeValue, attributeType, attributeDomain, attributeFormat, intl) {
+export function _prepareAttributeValue(attributeValue, attributeType, attributeDomain, attributeFormat, intl) {
+  if (attributeValue === null || typeof attributeValue === "undefined") {
+    return "";
+  }
   if (attributeDomain && attributeDomain.type === "coded-value") {
     // "coded-value" domain field
     const value = attributeDomain.getName(attributeValue);
-    return value;
+    return value.toString();
   }
   else {
     // Non-domain field or unsupported domain type
@@ -338,9 +443,7 @@ function _prepareAttributeValue(attributeValue, attributeType, attributeDomain,
  * @param includeHeaderNames Add the label format at the front of the list of generated labels
  * @returns Promise resolving when function is done
  */
-async function _prepareLabels(layer, ids, formatUsingLayerPopup = true, includeHeaderNames = false) {
-  var _a, _b, _c, _d;
-  const [intl] = await loadModules(["esri/intl"]);
+export async function _prepareLabels(layer, ids, formatUsingLayerPopup = true, includeHeaderNames = false) {
   // Get the features to export
   const featureSet = await queryFeaturesByID(ids, layer, [], false);
   // Get field data types. Do we have any domain-based fields?
@@ -352,179 +455,96 @@ async function _prepareLabels(layer, ids, formatUsingLayerPopup = true, includeH
   });
   const attributeFormats = {};
   // Get the label formatting, if any
-  let labelFormat;
-  let relationshipQueries = {};
-  let arcadeExecutors = {};
-  if (layer.popupEnabled) {
-    layer.popupTemplate.fieldInfos.forEach(
-    // Extract any format info that we have
-    fieldInfo => {
-      if (fieldInfo.format) {
-        attributeFormats[fieldInfo.fieldName] = fieldInfo.format;
-      }
-    });
-    // What data fields are used in the labels?
-    // Example labelFormat: ['{NAME}', '{STREET}', '{CITY}, {STATE} {ZIP}']
-    if (formatUsingLayerPopup && ((_b = (_a = layer.popupTemplate) === null || _a === void 0 ? void 0 : _a.content[0]) === null || _b === void 0 ? void 0 : _b.type) === "fields") {
-      labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos);
-      // If popup is configured with "no attribute information", then no fields will visible
-      if (labelFormat.length === 0) {
-        // Can we use the popup title?
-        // eslint-disable-next-line unicorn/prefer-ternary
-        if (typeof layer.popupTemplate.title === "string") {
-          labelFormat = layer.popupTemplate.title;
-          // Otherwise revert to using attributes
-        }
-        else {
-          labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos, true);
-        }
-      }
-    }
-    else if (formatUsingLayerPopup && ((_d = (_c = layer.popupTemplate) === null || _c === void 0 ? void 0 : _c.content[0]) === null || _d === void 0 ? void 0 : _d.type) === "text") {
-      labelFormat = _convertPopupTextToLabelSpec(layer.popupTemplate.content[0].text);
-      // Do we need any relationship queries?
-      relationshipQueries = _createRelationshipQueries(layer);
-      // Do we need any Arcade executors?
-      arcadeExecutors = await _createArcadeExecutors(labelFormat, layer);
-    }
-  }
+  const labelFormat = await _getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
   // Apply the label format
-  let labels;
-  // eslint-disable-next-line unicorn/prefer-ternary
-  if (labelFormat) {
-    // Find the label fields that we need to replace with values
-    const arcadeExpressionMatches = _getExpressionsFromLabel(labelFormat);
-    const attributeMatches = _getFieldsFromLabel(labelFormat);
-    // Convert feature attributes into an array of labels
-    const relationshipKeys = Object.keys(relationshipQueries);
-    labels = await Promise.all(featureSet.map(async (feature) => {
-      let labelPrep = labelFormat;
-      // Replace Arcade expressions in this feature
-      arcadeExpressionMatches.forEach((match) => {
-        const expressionName = match.substring(match.indexOf("/") + 1, match.length - 1);
-        const value = arcadeExecutors[expressionName].execute({ "$feature": feature });
-        labelPrep = labelPrep.replace(match, value);
-      });
-      // Replace relationship expressions in this feature
-      const relatedFeatureQueries = [];
-      const relationshipIds = [];
-      relationshipKeys.forEach((relationshipId) => {
-        const relationship = relationshipQueries[relationshipId];
-        const objectId = feature.attributes[relationship.layer.objectIdField];
-        const relatedQuery = Object.assign(Object.assign({}, relationship.relatedQuery), { objectIds: [objectId] });
-        relatedFeatureQueries.push(relationship.layer.queryRelatedFeatures(relatedQuery));
-        relationshipIds.push(relationshipId);
-      });
-      // Wait for all of the queries for related records for this label
-      const relatedFeatureQueryResults = await Promise.all(relatedFeatureQueries);
-      relatedFeatureQueryResults.forEach((relatedFeatureQueryResult, i) => {
-        // We have an object with FeatureSets grouped by source layer or table objectIds
-        const relationshipId = relationshipIds[i];
-        // Run through the source layer or table objectIds
-        Object.keys(relatedFeatureQueryResult).forEach(relatedFeatureSetId => {
-          // We have a feature set
-          const relatedFeatures = relatedFeatureQueryResult[relatedFeatureSetId].features;
-          // Get the values from each feature and replace them in the label
-          relatedFeatures.forEach(feature => {
-            // Merge the base and related feature attributes and create the label
-            // Prefix related feature's attributes with "relationships/<id>/" to match popup
-            const rePrefix = "\{relationships/" + relationshipId + "/";
-            const reSuffix = "\}";
-            const attributes = feature.attributes;
-            Object.keys(attributes).forEach(attributeName => {
-              // Replace the value using the attribute name as a relationship
-              const attributeRelationshipRegExp = new RegExp(rePrefix + attributeName + reSuffix, "g");
-              labelPrep = labelPrep.replaceAll(attributeRelationshipRegExp, attributes[attributeName]);
-            });
-          });
-        });
-      });
-      // Replace non-Arcade fields in this feature
-      attributeMatches.forEach((match) => {
-        const attributeName = match.substring(1, match.length - 1);
-        const value = _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], attributeFormats[attributeName], intl);
-        labelPrep = labelPrep.replace(match, value);
-      });
-      // Split label into lines
-      let label = labelPrep.split(lineSeparatorChar);
-      // Trim lines
-      label = label.map(line => line.trim());
-      return label;
-    }));
-  }
-  else {
+  const labels = labelFormat.type === "unsupported" ?
     // Export all attributes
-    labels = featureSet.map(feature => {
-      return Object.keys(feature.attributes).map((attributeName) => {
-        const value = _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], null, intl);
-        return `${value}`;
-      });
+    await _prepareLabelsFromAll(featureSet, attributeTypes, attributeDomains, includeHeaderNames)
+    : labelFormat.type == "pattern" ?
+      // Export attributes in format
+      await _prepareLabelsFromPattern(featureSet, attributeTypes, attributeDomains, attributeFormats, labelFormat.format, includeHeaderNames)
+      :
+        // Export attributes in expression
+        await _prepareLabelsUsingExecutor(featureSet, labelFormat.format);
+  return Promise.resolve(labels);
+}
+/**
+ * Creates labels from all attributes in items.
+ *
+ * @param featureSet Features to convert to labels
+ * @param attributeTypes Type for each attribute in a feature
+ * @param attributeDomains Domains for each attribute in a feature
+ * @param includeHeaderNames Add the label format at the front of the list of generated labels
+ * @returns Promise resolving with list of labels, each of which is a list of label lines
+ */
+export async function _prepareLabelsFromAll(featureSet, attributeTypes, attributeDomains, includeHeaderNames = false) {
+  const [intl] = await loadModules(["esri/intl"]);
+  // Export all attributes
+  const labels = featureSet.map(feature => {
+    return Object.keys(feature.attributes).map((attributeName) => {
+      return _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], null, intl);
     });
-  }
+  });
   // Add header names
   if (includeHeaderNames) {
-    let headerNames = [];
-    if (labelFormat) {
-      headerNames = labelFormat.replace(/\{/g, "").replace(/\}/g, "").split(lineSeparatorChar);
-    }
-    else {
-      const featuresAttrs = featureSet[0].attributes;
-      Object.keys(featuresAttrs).forEach(k => {
-        headerNames.push(k);
-      });
-    }
+    const headerNames = [];
+    const featuresAttrs = featureSet[0].attributes;
+    Object.keys(featuresAttrs).forEach(k => {
+      headerNames.push(k);
+    });
     labels.unshift(headerNames);
   }
   return Promise.resolve(labels);
 }
 /**
- * Remove any duplicate labels
+ * Creates labels from attributes in a layer popup.
  *
- * @param labels Labels to evaluate for duplicates
- * @returns labels with duplicates removed
- */
-export function removeDuplicateLabels(labels) {
-  const labelsAsStrings = labels.map(label => JSON.stringify(label));
-  const uniqueLabels = new Set(labelsAsStrings);
-  return Array.from(uniqueLabels, labelString => JSON.parse(labelString));
-}
-/**
- * Extract selectionSetNames from the provided exportInfos
- *
- * @param exportInfos Key details about what to export (ids, layer, and selectionSetNames)
- * @returns selectionSetNames that will be used for export filenames
+ * @param featureSet Features to convert to labels
+ * @param attributeTypes Type for each attribute in a feature
+ * @param attributeDomains Domains for each attribute in a feature
+ * @param attributeFormats Formats for each attribute in a feature
+ * @param labelFormat Format for label
+ * @param includeHeaderNames Add the label format at the front of the list of generated labels
+ * @returns Promise resolving with list of labels, each of which is a list of label lines
  */
-function _getSelectionSetNames(exportInfos, id = /.+/) {
-  let selectionSetNames = [];
-  Object.keys(exportInfos).forEach(k => {
-    const exportInfo = exportInfos[k];
-    if (id.test(k)) {
-      selectionSetNames = selectionSetNames.concat(exportInfo.selectionSetNames);
-    }
-  });
-  return selectionSetNames;
+export async function _prepareLabelsFromPattern(featureSet, attributeTypes, attributeDomains, attributeFormats, labelFormat, includeHeaderNames = false) {
+  const [intl] = await loadModules(["esri/intl"]);
+  // Find the label fields that we need to replace with values
+  const attributeExpressionMatches = _getFieldExpressionsFromLabel(labelFormat);
+  const attributeNames = _getFieldNamesFromFieldExpressions(attributeExpressionMatches);
+  // Convert feature attributes into an array of labels
+  const labels = await Promise.all(featureSet.map(async (feature) => {
+    let labelPrep = labelFormat;
+    // Replace non-Arcade fields in this feature
+    attributeNames.forEach((attributeName, i) => {
+      const value = _prepareAttributeValue(feature.attributes[attributeName], attributeTypes[attributeName], attributeDomains[attributeName], attributeFormats[attributeName], intl);
+      labelPrep = labelPrep.replace(attributeExpressionMatches[i], value);
+    });
+    // Split label into lines
+    let label = labelPrep.split(lineSeparatorChar);
+    // Trim lines
+    label = label.map(line => _cleanupLabel(line));
+    return label;
+  }));
+  // Add header names
+  if (includeHeaderNames) {
+    labels.unshift(attributeNames);
+  }
+  return Promise.resolve(labels);
 }
 /**
- * Create and consolidate labels from all layers
+ * Creates labels from attributes in an Arcade label.
  *
- * @param exportInfos Key details about what to export (ids, layer, and selectionSetNames)
- * @param formatUsingLayerPopup When true, the layer's popup is used to choose attributes for each column; when false,
- * all attributes are exported
- * @param includeHeaderNames Add the label format at the front of the list of generated labels
- * @returns selectionSetNames that will be used for export filenames
+ * @param featureSet Features to convert to labels
+ * @param labelFormat Arcade executor for label
+ * @returns Promise resolving with list of labels, each of which is a list of label lines
  */
-export async function consolidateLabels(exportInfos, formatUsingLayerPopup = true, includeHeaderNames = false, isCSVExport = false) {
-  const labelRequests = [];
-  Object.keys(exportInfos).forEach(k => {
-    var _a;
-    const labelInfo = exportInfos[k];
-    labelRequests.push(_prepareLabels(((_a = labelInfo.layerView) === null || _a === void 0 ? void 0 : _a.layer) || labelInfo.layer, labelInfo.ids, formatUsingLayerPopup, includeHeaderNames));
-    if (isCSVExport) {
-      // add the layer id as a temp value separator that we can use to split values for CSV export
-      labelRequests.push(Promise.resolve([[k]]));
-    }
-  });
-  const labels = await Promise.all(labelRequests);
-  return labels.reduce((prev, cur) => prev.concat(cur), []);
+export async function _prepareLabelsUsingExecutor(featureSet, labelFormat) {
+  // Convert feature attributes into an array of labels
+  const execResults = await Promise.all(featureSet.map(async (feature) => {
+    return labelFormat.executeAsync({ "$feature": feature });
+  }));
+  const labels = execResults.map(result => _cleanupLabel(result.text).split(lineSeparatorChar));
+  return Promise.resolve(labels);
 }
 //#endregion