@esri/solutions-components 0.6.8 → 0.6.10

package/dist/solutions-components/utils/downloadUtils.ts

@@ -24,32 +24,33 @@ import { IExportInfo, IExportInfos } from "../utils/interfaces";
 
 export { ILabel } from "./pdfUtils";
 
-interface IArcadeExecutors {
-  [expressionName: string]: __esri.ArcadeExecutor;
+export interface IAttributeOrigNames {
+  [lowercaseName: string]: string;
 }
 
-interface IArcadeExecutorPromises {
-  [expressionName: string]: Promise<__esri.ArcadeExecutor>;
-}
-
-interface IAttributeDomains {
+export interface IAttributeDomains {
   [attributeName: string]: __esri.CodedValueDomain | __esri.RangeDomain | __esri.InheritedDomain | null;
 }
 
-interface IAttributeFormats {
+export interface IAttributeFormats {
   [attributeName: string]: __esri.FieldInfoFormat;
 }
 
-interface IAttributeTypes {
+export interface IAttributeTypes {
   [attributeName: string]: string;
 }
 
-interface ILayerRelationshipQuery {
+export interface ILabelFormat {
+  type: "pattern" | "executor" | "unsupported";
+  format: string | __esri.ArcadeExecutor | undefined;
+}
+
+export interface ILayerRelationshipQuery {
   layer: __esri.FeatureLayer;
   relatedQuery: IRelatedFeaturesQuery;
 }
 
-interface ILayerRelationshipQueryHash {
+export interface ILayerRelationshipQueryHash {
   [relationshipId: string]: ILayerRelationshipQuery;
 }
 
@@ -66,8 +67,39 @@ interface IRelatedFeaturesQuery {
 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: IExportInfos,
+  formatUsingLayerPopup = true,
+  includeHeaderNames = false,
+  isCSVExport = false
+): Promise<string[][]> {
+  const labelRequests = [];
+
+  Object.keys(exportInfos).forEach(k => {
+    const labelInfo: IExportInfo = exportInfos[k];
+    labelRequests.push(_prepareLabels(labelInfo.layerView?.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
  *
@@ -140,59 +172,51 @@ export async function downloadPDF(
   return Promise.resolve();
 }
 
-//#endregion
-//#region Private functions
-
 /**
- * Converts a set of fieldInfos into template lines.
+ * Remove any duplicate labels
  *
- * @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`
+ * @param labels Labels to evaluate for duplicates
+ * @returns labels with duplicates removed
  */
-export function _convertPopupFieldsToLabelSpec(
-  fieldInfos: __esri.FieldInfo[],
-  bypassFieldVisiblity = false
-): string {
-  const labelSpec: string[] = [];
-
-  // Every visible attribute is used
-  fieldInfos.forEach(
-    fieldInfo => {
-      if (fieldInfo.visible || bypassFieldVisiblity) {
-        labelSpec.push(`{${fieldInfo.fieldName}}`);
-      }
-    }
+export function removeDuplicateLabels(
+  labels: string[][]
+): string[][] {
+  const labelsAsStrings: string[] = labels.map(label => JSON.stringify(label));
+  const uniqueLabels = new Set(labelsAsStrings);
+  return Array.from(uniqueLabels,
+    labelString => JSON.parse(labelString)
   );
+}
 
-  return labelSpec.join(lineSeparatorChar);
-};
+//#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. It does not handle Arcade and related records.
+ * lines on <br>s, and removes HTML tags.
  *
- * @param popupInfo Layer's popupInfo structure containing description, fieldInfos, and expressionInfos, e.g.,
+ * @param labelText Layer's popup text, 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 Cleaned-up popup text with lines separated by `lineSeparatorChar`
  */
-export function _convertPopupTextToLabelSpec(
-  popupInfo: string,
+export function _cleanupLabel(
+  labelText: string,
 ): string {
   // Replace <br> variants with the line separator character
-  popupInfo = popupInfo.replace(/<br\s*\/?>/gi, lineSeparatorChar);
+  labelText = labelText.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(/^\|/, "");
+  labelText = labelText.replace(/<p[^>]*>/gi, lineSeparatorChar).trim().replace(/^\|/, "");
 
   // Remove </p>
-  popupInfo = popupInfo.replace(/<\/p>/gi, "");
+  labelText = labelText.replace(/<\/p>/gi, "");
 
   // Replace \n with the line separator character
-  popupInfo = popupInfo.replace(/\n/gi, "|");
+  labelText = labelText.replace(/\n/gi, "|");
 
   // Remove remaining HTML tags, replace 0xA0 that popup uses for spaces, and replace some char representations
-  let labelSpec = popupInfo
+  labelText = labelText
     .replace(/<[\s.]*[^<>]*\/?>/gi, "")
     .replace(/\xA0/gi, " ")
     .replace(/&lt;/gi, "<")
@@ -200,47 +224,75 @@ export function _convertPopupTextToLabelSpec(
     .replace(/&nbsp;/gi, " ");
 
   // Trim each line
-  labelSpec = labelSpec.replace(/\s*\|\s*/g, "|");
+  labelText = labelText.replace(/\s*\|\s*/g, "|");
 
   // Remove empty lines
-  while (labelSpec.match(/\|\|/)) {
-    labelSpec = labelSpec.replace(/\|\|/, "|");
+  while (labelText.match(/\|\|/)) {
+    labelText = labelText.replace(/\|\|/, "|");
   }
 
   // Remove leading and trailing line feeds
-  labelSpec = labelSpec.replace(/^\|/, "");
-  labelSpec = labelSpec.replace(/\|$/, "");
+  labelText = labelText.replace(/^\|/, "");
+  labelText = labelText.replace(/\|$/, "");
 
-  return labelSpec.trim();
+  return labelText;
 };
 
 /**
- * Extracts Arcade expressions from the lines of a label format and creates an Arcade executor for each
- * referenced expression name.
+ * Converts a set of fieldInfos into template lines.
  *
- * @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 fieldInfos Layer's fieldInfos structure
+ * @param bypassFieldVisiblity Indicates if the configured fieldInfo visibility property should be ignored
+ * @return "pattern" label spec with lines separated by `lineSeparatorChar`
  */
-async function _createArcadeExecutors(
-  labelFormat: string,
-  layer: __esri.FeatureLayer
-): Promise<IArcadeExecutors> {
-  const arcadeExecutors: IArcadeExecutors = {};
+export function _convertPopupFieldsToLabelSpec(
+  fieldInfos: __esri.FieldInfo[],
+  bypassFieldVisiblity = false
+): ILabelFormat {
+  const labelSpec: string[] = [];
 
-  // Are any Arcade expressions in the layer?
-  if (!Array.isArray(layer.popupTemplate.expressionInfos) || layer.popupTemplate.expressionInfos.length === 0) {
-    return Promise.resolve(arcadeExecutors);
-  }
+  // Every visible attribute is used
+  fieldInfos.forEach(
+    fieldInfo => {
+      if (fieldInfo.visible || bypassFieldVisiblity) {
+        labelSpec.push(`{${fieldInfo.fieldName}}`);
+      }
+    }
+  );
 
-  // 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);
-  }
+  return {
+    type: "pattern",
+    format: labelSpec.join(lineSeparatorChar)
+  } as ILabelFormat;
+};
+
+/**
+ * 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 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 "pattern" label spec with lines separated by `lineSeparatorChar`
+ */
+export function _convertPopupTextToLabelSpec(
+  popupInfo: string,
+): ILabelFormat {
+  return {
+    type: "pattern",
+    format: _cleanupLabel(popupInfo)
+  } as ILabelFormat;
+};
 
-  // Generate an Arcade executor for each match
+/**
+ * Converts an Arcade expression of a custom popup into a multiline label specification.
+ *
+ * @param expressionInfo Structure containing expression and info about it
+ * @return Promise resolving to an "executor" label spec
+ */
+export async function _convertPopupArcadeToLabelSpec(
+  expressionInfo: __esri.ElementExpressionInfo
+): Promise<ILabelFormat> {
+  // Generate an Arcade executor
   const [arcade] = await loadModules(["esri/arcade"]);
   const labelingProfile: __esri.Profile = {
     variables: [
@@ -262,36 +314,12 @@ async function _createArcadeExecutors(
       }
     ]
   };
+  const executor = await arcade.createArcadeExecutor(expressionInfo.expression, labelingProfile);
 
-  const createArcadeExecutorPromises: IArcadeExecutorPromises = {};
-  arcadeExpressionsMatches.forEach(
-    (match: string) => {
-      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() as __esri.ArcadeExecutor;
-      }
-
-      return arcadeExecutors;
-    }
-  );
+  return Promise.resolve({
+    type: "executor",
+    format: executor
+  } as ILabelFormat);
 }
 
 /**
@@ -349,12 +377,12 @@ export function _createRelationshipQueries(
 
 /**
  * Extracts Arcade expression references from the lines of a label format.
- * 
+ *
  * @param labelFormat Label to examine
  * @return Array of Arcade expression references, e.g., ["{expression/expr1}", "{expression/expr2}"]
  */
 export function _getExpressionsFromLabel(
-  labelFormat: string  
+  labelFormat: string
 ): string[] {
   const arcadeExpressionRegExp = /\{expression\/\w+\}/g;
   return labelFormat.match(arcadeExpressionRegExp) ?? [];
@@ -362,11 +390,11 @@ export function _getExpressionsFromLabel(
 
 /**
  * Extracts field name expressions from the lines of a label format.
- * 
+ *
  * @param labelFormat Label to examine
  * @returns Array of field name expressions, e.g., ["{NAME}", "{STREET}", "{CITY}", "{STATE}", "{ZIP}"]
  */
-export function _getFieldsFromLabel(
+export function _getFieldExpressionsFromLabel(
   labelFormat: string
 ): string[] {
   // Get all fields
@@ -390,6 +418,99 @@ export function _getFieldsFromLabel(
   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: string[]
+): string[] {
+  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 with fields coerced to lowercase, e.g.,
+ * for ILabelFormat type "pattern": "{name}|{street}|{city}, {state} {zip}"
+ */
+export async function _getLabelFormat(
+  layer: __esri.FeatureLayer,
+  formatUsingLayerPopup: boolean,
+  attributeFormats: IAttributeFormats
+): Promise<ILabelFormat> {
+  let labelFormat: ILabelFormat = {
+    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.toLowerCase()] = fieldInfo.format;
+        }
+      }
+    );
+
+    // What is the nature of the label content?
+    // Fields list
+    if (formatUsingLayerPopup && layer.popupTemplate?.content[0]?.type === "fields") {
+      labelFormat = _convertPopupFieldsToLabelSpec(layer.popupTemplate.fieldInfos);
+
+      // If popup is configured with "no attribute information", then no fields will visible
+      if ((labelFormat.format as string).length === 0) {
+        // Can we use the popup title?
+        labelFormat = layer.popupTemplate.title && typeof layer.popupTemplate.title === "string" ?
+          { type: "pattern", format: layer.popupTemplate.title } as ILabelFormat
+          :
+          // 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 && layer.popupTemplate?.content[0]?.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 && layer.popupTemplate?.content[0]?.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: IExportInfos,
+  id = /.+/
+): string[] {
+  let selectionSetNames: string[] = [];
+  Object.keys(exportInfos).forEach(k => {
+    const exportInfo: IExportInfo = exportInfos[k];
+    if (id.test(k)) {
+      selectionSetNames = selectionSetNames.concat(exportInfo.selectionSetNames);
+    }
+  });
+  return selectionSetNames;
+}
+
 /**
  * Prepares an attribute's value by applying domain and type information.
  *
@@ -398,19 +519,23 @@ export function _getFieldsFromLabel(
  * @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(
+export function _prepareAttributeValue(
   attributeValue: any,
   attributeType: string,
   attributeDomain: __esri.CodedValueDomain | __esri.RangeDomain | __esri.InheritedDomain | null,
   attributeFormat: __esri.FieldInfoFormat,
   intl: any
-): any {
+): string {
+  if (attributeValue === null || typeof attributeValue === "undefined") {
+    return "";
+  }
+
   if (attributeDomain && (attributeDomain as __esri.CodedValueDomain).type === "coded-value") {
     // "coded-value" domain field
     const value = (attributeDomain as __esri.CodedValueDomain).getName(attributeValue);
-    return value;
+    return value.toString();
   } else {
     // Non-domain field or unsupported domain type
     let value = attributeValue;
@@ -418,7 +543,7 @@ function _prepareAttributeValue(
     switch (attributeType) {
       case "date":
         if (attributeFormat?.dateFormat) {
-          const dateFormatIntlOptions = intl.convertDateFormatToIntlOptions(attributeFormat.dateFormat);
+          const dateFormatIntlOptions = intl.convertDateFormatToIntlOptions(attributeFormat.dateFormat as any);
           value = intl.formatDate(value, dateFormatIntlOptions);
         } else {
           value = intl.formatDate(value);
@@ -455,199 +580,85 @@ function _prepareAttributeValue(
  * @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(
+export async function _prepareLabels(
   layer: __esri.FeatureLayer,
   ids: number[],
   formatUsingLayerPopup = true,
   includeHeaderNames = false
 ): Promise<string[][]> {
-  const [intl] = await loadModules(["esri/intl"]);
-
   // Get the features to export
   const featureSet = await queryFeaturesByID(ids, layer, [], false);
 
   // Get field data types. Do we have any domain-based fields?
+  const attributeOrigNames: IAttributeOrigNames = {};
   const attributeTypes: IAttributeTypes = {};
   const attributeDomains: IAttributeDomains = {};
   layer.fields.forEach(
     field => {
-      attributeTypes[field.name] = field.type;
-      attributeDomains[field.name] = field.domain;
+      const lowercaseFieldname = field.name.toLowerCase();
+      attributeOrigNames[lowercaseFieldname] = field.name;
+      attributeDomains[lowercaseFieldname] = field.domain;
+      attributeTypes[lowercaseFieldname] = field.type;
     }
   );
   const attributeFormats: IAttributeFormats = {};
 
   // Get the label formatting, if any
-  let labelFormat: string;
-  let relationshipQueries: ILayerRelationshipQueryHash = {};
-  let arcadeExecutors: IArcadeExecutors = {};
-  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 && layer.popupTemplate?.content[0]?.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 && layer.popupTemplate?.content[0]?.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: ILabelFormat = await _getLabelFormat(layer, formatUsingLayerPopup, attributeFormats);
 
   // Apply the label format
-  let labels: string[][];
-  // 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: string) => {
-            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 = [] as Promise<__esri.FeatureSet>[];
-        const relationshipIds = [] as string[];
-        relationshipKeys.forEach(
-          (relationshipId) => {
-            const relationship = relationshipQueries[relationshipId];
-            const objectId = feature.attributes[relationship.layer.objectIdField];
-            const relatedQuery = {
-              ...relationship.relatedQuery,
-              objectIds: [objectId]
-            };
-            relatedFeatureQueries.push(relationship.layer.queryRelatedFeatures(relatedQuery as any));
-            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: string) => {
-            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: string) => {
-            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, attributeOrigNames, attributeTypes, attributeDomains,
+      attributeFormats, labelFormat.format as string, includeHeaderNames)
+    :
+    // Export attributes in expression
+    await _prepareLabelsUsingExecutor(featureSet, labelFormat.format as __esri.ArcadeExecutor);
 
-  // Add header names
-  if (includeHeaderNames) {
-    let headerNames = [];
+  return Promise.resolve(labels);
+}
 
-    if (labelFormat) {
-      headerNames = labelFormat.replace(/\{/g, "").replace(/\}/g, "").split(lineSeparatorChar);
+/**
+ * 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: __esri.Graphic[],
+  attributeTypes: IAttributeTypes,
+  attributeDomains: IAttributeDomains,
+  includeHeaderNames = false
+): Promise<string[][]> {
+  const [intl] = await loadModules(["esri/intl"]);
 
-    } else {
-      const featuresAttrs = featureSet[0].attributes;
-      Object.keys(featuresAttrs).forEach(k => {
-        headerNames.push(k);
-      });
+  // Export all attributes
+  const labels = featureSet.map(
+    feature => {
+      return Object.keys(feature.attributes).map(
+        (attributeName: string) => {
+          const lowercaseFieldname = attributeName.toLowerCase();
+          return _prepareAttributeValue(feature.attributes[attributeName],
+            attributeTypes[lowercaseFieldname], attributeDomains[lowercaseFieldname],
+            null, intl);
+        }
+      );
     }
+  );
 
+  // Add header names
+  if (includeHeaderNames) {
+    const headerNames = [];
+    const featuresAttrs = featureSet[0].attributes;
+    Object.keys(featuresAttrs).forEach(k => {
+      headerNames.push(k);
+    });
     labels.unshift(headerNames);
   }
 
@@ -655,69 +666,90 @@ async function _prepareLabels(
 }
 
 /**
- * Remove any duplicate labels
+ * Creates labels from attributes in a layer popup.
  *
- * @param labels Labels to evaluate for duplicates
- * @returns labels with duplicates removed
+ * @param featureSet Features to convert to labels
+ * @param attributeOrigNames Mapping from lowercase field names to original field names
+ * @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
  */
-export function removeDuplicateLabels(
-  labels: string[][]
-): string[][] {
-  const labelsAsStrings: string[] = labels.map(label => JSON.stringify(label));
-  const uniqueLabels = new Set(labelsAsStrings);
-  return Array.from(uniqueLabels,
-    labelString => JSON.parse(labelString)
-  );
-}
+export async function _prepareLabelsFromPattern(
+  featureSet: __esri.Graphic[],
+  attributeOrigNames: IAttributeOrigNames,
+  attributeTypes: IAttributeTypes,
+  attributeDomains: IAttributeDomains,
+  attributeFormats: IAttributeFormats,
+  labelFormat: string,
+  includeHeaderNames = false
+): Promise<string[][]> {
+  const [intl] = await loadModules(["esri/intl"]);
 
-/**
- * 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
- */
-function _getSelectionSetNames(
-  exportInfos: IExportInfos,
-  id = /.+/
-): string[] {
-  let selectionSetNames: string[] = [];
-  Object.keys(exportInfos).forEach(k => {
-    const exportInfo: IExportInfo = exportInfos[k];
-    if (id.test(k)) {
-      selectionSetNames = selectionSetNames.concat(exportInfo.selectionSetNames);
+  // 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: string, i: number) => {
+          const lowercaseFieldname = attributeName.toLowerCase();
+          const value = _prepareAttributeValue(feature.attributes[attributeOrigNames[lowercaseFieldname]],
+            attributeTypes[lowercaseFieldname], attributeDomains[lowercaseFieldname],
+            attributeFormats[lowercaseFieldname], 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;
     }
-  });
-  return selectionSetNames;
+  ));
+
+  // 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: IExportInfos,
-  formatUsingLayerPopup = true,
-  includeHeaderNames = false,
-  isCSVExport = false
+export async function _prepareLabelsUsingExecutor(
+  featureSet: __esri.Graphic[],
+  labelFormat: __esri.ArcadeExecutor
 ): Promise<string[][]> {
-  const labelRequests = [];
-
-  Object.keys(exportInfos).forEach(k => {
-    const labelInfo: IExportInfo = exportInfos[k];
-    labelRequests.push(_prepareLabels(labelInfo.layerView?.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]]));
+  // Convert feature attributes into an array of labels
+  const execResults = await Promise.all(featureSet.map(
+    async feature => {
+      return labelFormat.executeAsync({"$feature": feature});
     }
-  });
+  ));
 
-  const labels = await Promise.all(labelRequests);
-  return labels.reduce((prev, cur) => prev.concat(cur), []);
+  const labels = execResults.map(
+    result => _cleanupLabel(result.text).split(lineSeparatorChar)
+  )
+
+  return Promise.resolve(labels);
 }
 
 //#endregion