@plusscommunities/pluss-feature-builder-app-c 1.0.1-beta.3

package/dist/module/components/FeatureDetailScreen.js

@@ -0,0 +1,725 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import React, { Component } from "react";
+import { SPACING } from "../js/spacing";
+import { Platform, View, ScrollView, Animated, Dimensions, StatusBar, Text, TouchableOpacity, Linking, StyleSheet, KeyboardAvoidingView, Image } from "react-native";
+import { Icon } from "react-native-elements";
+import { connect } from "react-redux";
+import _ from "lodash";
+import { LinearGradient } from "expo-linear-gradient";
+import { Services } from "../feature.config";
+import { Components, Colours, COLOUR_TRANSPARENT, TEXT_DARK } from "../core.config";
+import { TEXT_MID, LINEGREY } from "../js/Colors";
+import FileDownload from "./FileDownload";
+import { values } from "../values.config";
+import { selectFeatureDefinition } from "../reducers/featureBuilderReducer";
+import Constants from "expo-constants";
+import { InlineButton } from "./common";
+import { FIELD_TYPES } from "../js/FieldTypes";
+const SCREEN_HEIGHT = Dimensions.get("window").height;
+const CARD_IMAGE_HEIGHT = SCREEN_HEIGHT * 0.3;
+const SCREEN_WIDTH = Dimensions.get("window").width;
+
+// StatusBarHeight function copied to avoid import from outside extension
+const StatusBarHeight = size => {
+  return getStatusBarHeight() + size;
+};
+const getStatusBarHeight = () => {
+  return Platform.OS === "ios" ? Constants.statusBarHeight : StatusBar.currentHeight;
+};
+class FeatureDetailScreen extends Component {
+  constructor(props) {
+    super(props);
+    _defineProperty(this, "onPressBack", () => {
+      Services.navigation.goBack();
+    });
+    /**
+     * Collect all images from listing fields
+     */
+    _defineProperty(this, "collectAllImages", () => {
+      const {
+        listing,
+        featureDefinition
+      } = this.props;
+      if (!listing || !listing.fields || !featureDefinition) {
+        return [];
+      }
+      const allImages = [];
+      const fieldDefinitions = featureDefinition.fields || [];
+
+      // Add primary feature image first
+      const primaryImage = listing.fields[values.mandatoryFields.featureImage];
+      if (primaryImage) {
+        const imageObj = this.normalizeImageField(primaryImage);
+        if (imageObj) {
+          allImages.push({
+            ...imageObj,
+            fieldId: values.mandatoryFields.featureImage,
+            fieldLabel: values.labels.featureImage
+          });
+        }
+      }
+
+      // Add additional image fields
+      fieldDefinitions.forEach(fieldDef => {
+        if ((fieldDef.type === FIELD_TYPES.IMAGE || fieldDef.type === FIELD_TYPES.GALLERY) && fieldDef.id !== values.mandatoryFields.featureImage) {
+          const fieldValue = listing.fields[fieldDef.id];
+          if (fieldValue) {
+            if (fieldDef.type === FIELD_TYPES.GALLERY) {
+              // Handle Gallery (Array of images)
+              if (Array.isArray(fieldValue)) {
+                fieldValue.forEach(item => {
+                  const imageObj = this.normalizeImageField(item);
+                  if (imageObj) {
+                    allImages.push({
+                      ...imageObj,
+                      fieldId: fieldDef.id,
+                      fieldLabel: fieldDef.label || fieldDef.id
+                    });
+                  }
+                });
+              }
+            } else {
+              // Handle Single Image
+              const imageObj = this.normalizeImageField(fieldValue);
+              if (imageObj) {
+                allImages.push({
+                  ...imageObj,
+                  fieldId: fieldDef.id,
+                  fieldLabel: fieldDef.label || fieldDef.id
+                });
+              }
+            }
+          }
+        }
+      });
+      return allImages;
+    });
+    /**
+     * Normalize image field to object format
+     */
+    _defineProperty(this, "normalizeImageField", imageField => {
+      if (!imageField) return null;
+      if (typeof imageField === "string") {
+        return {
+          uri: imageField,
+          url: imageField
+        };
+      }
+      if (typeof imageField === "object") {
+        if (imageField.uri) {
+          return {
+            uri: imageField.uri,
+            url: imageField.uri,
+            ...imageField
+          };
+        }
+        if (imageField.url) {
+          return {
+            uri: imageField.url,
+            url: imageField.url,
+            ...imageField
+          };
+        }
+      }
+      return null;
+    });
+    /**
+     * Open image popup with all images
+     */
+    _defineProperty(this, "openImagePopup", (imageIndex = 0) => {
+      const {
+        allImages
+      } = this.state;
+      if (allImages.length > 0) {
+        this.setState({
+          showImagePopup: true,
+          selectedImageIndex: imageIndex
+        });
+      }
+    });
+    /**
+     * Close image popup
+     */
+    _defineProperty(this, "closeImagePopup", () => {
+      this.setState({
+        showImagePopup: false,
+        selectedImageIndex: 0
+      });
+    });
+    /**
+     * Handle link opening for various field types
+     */
+    _defineProperty(this, "handleLinkPress", url => {
+      if (url) {
+        Linking.openURL(url).catch(err => {
+          // Silently handle URL open errors
+        });
+      }
+    });
+    _defineProperty(this, "handleFilePress", file => {
+      if (file !== null && file !== void 0 && file.url) {
+        Linking.openURL(file.url).catch(err => {
+          // Silently handle URL open errors
+        });
+      }
+    });
+    this.state = {
+      isHomeTab: false,
+      showImagePopup: false,
+      selectedImageIndex: 0,
+      allImages: []
+    };
+  }
+  componentDidMount() {
+    this.setState({
+      isHomeTab: !Services.navigation.getParentRoute(),
+      allImages: this.collectAllImages()
+    });
+  }
+  componentDidUpdate(prevProps) {
+    // Recalculate allImages when listing or featureDefinition changes
+    if (prevProps.listing !== this.props.listing || prevProps.featureDefinition !== this.props.featureDefinition) {
+      this.setState({
+        allImages: this.collectAllImages()
+      });
+    }
+  }
+  componentWillUnmount() {
+    if (Platform.OS === "ios") StatusBar.setBarStyle("dark-content");
+  }
+  /**
+   * Process fields: filter out mandatory fields and sort by order
+   */
+  processFields() {
+    const {
+      listing,
+      featureDefinition
+    } = this.props;
+    if (!listing || !listing.fields || !featureDefinition) {
+      return [];
+    }
+    const fieldDefinitions = featureDefinition.fields || [];
+    const excludedFieldIds = new Set([values.mandatoryFields.title, values.mandatoryFields.featureImage]);
+
+    // Filter and map fields with their definitions
+    const filteredFields = Object.keys(listing.fields).filter(fieldId => {
+      if (!fieldId || excludedFieldIds.has(fieldId)) return false;
+      if (listing.fields[fieldId] == null) return false;
+
+      // Only include fields that have definitions
+      const hasDefinition = fieldDefinitions.some(f => f.id === fieldId);
+      if (!hasDefinition) {
+        return false;
+      }
+      return true;
+    }).map(fieldId => {
+      const fieldDefinition = fieldDefinitions.find(fieldDef => fieldDef.id === fieldId);
+      return {
+        fieldId,
+        fieldValue: listing.fields[fieldId],
+        fieldDefinition,
+        fieldType: (fieldDefinition === null || fieldDefinition === void 0 ? void 0 : fieldDefinition.type) || FIELD_TYPES.TEXT
+      };
+    });
+
+    // Sort by order property if available
+    return _.sortBy(filteredFields, field => {
+      var _field$fieldDefinitio;
+      return ((_field$fieldDefinitio = field.fieldDefinition) === null || _field$fieldDefinitio === void 0 ? void 0 : _field$fieldDefinitio.order) || 999;
+    });
+  }
+  /**
+   * Render individual field based on its type
+   */
+  renderField(fieldDef, fieldValue) {
+    const {
+      colourBrandingMain
+    } = this.props;
+
+    // Defensive: ensure fieldDef is always an object
+    const safeFieldDef = fieldDef || {};
+    const type = safeFieldDef.type || FIELD_TYPES.TEXT;
+    const label = safeFieldDef.label || safeFieldDef.id || "Unknown Field";
+    switch (type) {
+      case FIELD_TYPES.CTA:
+        {
+          const btnLabel = (fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.label) || label;
+          const btnUrl = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.url;
+          return /*#__PURE__*/React.createElement(View, {
+            style: styles.ctaContainer
+          }, /*#__PURE__*/React.createElement(InlineButton, {
+            large: true,
+            color: colourBrandingMain,
+            onPress: () => this.handleLinkPress(btnUrl)
+          }, btnLabel));
+        }
+      case FIELD_TYPES.EMAIL:
+        return /*#__PURE__*/React.createElement(TouchableOpacity, {
+          style: styles.linkContainer,
+          onPress: () => this.handleLinkPress(`mailto:${fieldValue}`)
+        }, /*#__PURE__*/React.createElement(Icon, {
+          type: "font-awesome",
+          name: "envelope",
+          size: 16,
+          color: colourBrandingMain,
+          style: styles.fieldIcon
+        }), /*#__PURE__*/React.createElement(Text, {
+          style: [styles.linkText, {
+            color: colourBrandingMain
+          }]
+        }, fieldValue));
+      case FIELD_TYPES.DATE:
+        return /*#__PURE__*/React.createElement(View, {
+          style: styles.dateContainer
+        }, /*#__PURE__*/React.createElement(Icon, {
+          type: "font-awesome",
+          name: "calendar",
+          size: 16,
+          color: TEXT_DARK,
+          style: styles.fieldIcon
+        }), /*#__PURE__*/React.createElement(Text, {
+          style: styles.bodyText
+        }, fieldValue));
+      case FIELD_TYPES.FILE:
+        {
+          // Handle both single file and multiple files (array)
+          const files = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+          return /*#__PURE__*/React.createElement(View, {
+            style: styles.filesContainer
+          }, /*#__PURE__*/React.createElement(Text, {
+            style: styles.sectionTitle
+          }, values.labels.attachments), files.map((file, index) => {
+            // Skip null/undefined files
+            if (!file) return null;
+            return /*#__PURE__*/React.createElement(FileDownload, {
+              key: index,
+              file: file,
+              onPress: this.handleFilePress,
+              color: this.props.colourBrandingMain
+            });
+          }));
+        }
+      case FIELD_TYPES.DESCRIPTION:
+        return /*#__PURE__*/React.createElement(Text, {
+          style: styles.descriptionText
+        }, fieldValue);
+      case FIELD_TYPES.IMAGE:
+        {
+          // Render secondary images inline with click handler
+          const imgUri = (fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.url) || (fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.uri) || (typeof fieldValue === "string" ? fieldValue : null);
+          if (!imgUri) return null;
+
+          // Find this image's index for popup
+          const {
+            allImages
+          } = this.state;
+          const imageIndex = allImages.findIndex(img => img.uri === imgUri || img.url === imgUri);
+          const caption = fieldValue === null || fieldValue === void 0 ? void 0 : fieldValue.caption;
+          return /*#__PURE__*/React.createElement(TouchableOpacity, {
+            onPress: () => this.openImagePopup(imageIndex),
+            activeOpacity: 0.8
+          }, /*#__PURE__*/React.createElement(Image, {
+            source: {
+              uri: imgUri
+            },
+            style: styles.inlineImage,
+            resizeMode: "cover"
+          }), caption && /*#__PURE__*/React.createElement(Text, {
+            style: styles.imageCaption
+          }, caption));
+        }
+      case FIELD_TYPES.GALLERY:
+        {
+          // Handle Gallery Fields (arrays of images)
+          if (!Array.isArray(fieldValue)) return null;
+          return /*#__PURE__*/React.createElement(View, {
+            style: {
+              marginVertical: 16
+            }
+          }, /*#__PURE__*/React.createElement(View, {
+            style: {
+              flexDirection: "row",
+              flexWrap: "wrap",
+              marginHorizontal: -4
+            }
+          }, fieldValue.map((imgItem, index) => {
+            const imgUri = (imgItem === null || imgItem === void 0 ? void 0 : imgItem.url) || (imgItem === null || imgItem === void 0 ? void 0 : imgItem.uri) || (typeof imgItem === "string" ? imgItem : null);
+            if (!imgUri) return null;
+
+            // Find global index for the popup
+            const {
+              allImages
+            } = this.state;
+            const globalIndex = allImages.findIndex(img => img.uri === imgUri || img.url === imgUri);
+            return /*#__PURE__*/React.createElement(TouchableOpacity, {
+              key: index,
+              onPress: () => this.openImagePopup(globalIndex !== -1 ? globalIndex : 0),
+              activeOpacity: 0.8,
+              style: {
+                width: "50%",
+                padding: 4
+              } // 2 column grid
+            }, /*#__PURE__*/React.createElement(Image, {
+              source: {
+                uri: imgUri
+              },
+              style: [styles.inlineImage, {
+                height: 150,
+                marginVertical: 0
+              }],
+              resizeMode: "cover"
+            }));
+          })));
+        }
+      case FIELD_TYPES.TITLE:
+        return /*#__PURE__*/React.createElement(Text, {
+          style: styles.titleText
+        }, fieldValue);
+      case FIELD_TYPES.NUMBER:
+        return /*#__PURE__*/React.createElement(Text, {
+          style: styles.numberText
+        }, fieldValue);
+      default:
+        // Default text fallback
+        return /*#__PURE__*/React.createElement(Text, {
+          style: styles.bodyText
+        }, typeof fieldValue === "object" ? JSON.stringify(fieldValue) : fieldValue);
+    }
+  }
+
+  /**
+   * Render all fields with proper spacing and structure
+   */
+  renderFields() {
+    const processedFields = this.processFields();
+    return processedFields.map((field, _index) => {
+      var _field$fieldDefinitio2, _field$fieldDefinitio3;
+      return /*#__PURE__*/React.createElement(View, {
+        key: field.fieldId,
+        style: styles.fieldContainer
+      }, field.fieldType !== FIELD_TYPES.CTA && field.fieldType !== FIELD_TYPES.IMAGE && ((_field$fieldDefinitio2 = field.fieldDefinition) === null || _field$fieldDefinitio2 === void 0 ? void 0 : _field$fieldDefinitio2.label) && /*#__PURE__*/React.createElement(Text, {
+        style: styles.fieldLabel
+      }, (_field$fieldDefinitio3 = field.fieldDefinition) === null || _field$fieldDefinitio3 === void 0 ? void 0 : _field$fieldDefinitio3.label), this.renderField(field.fieldDefinition, field.fieldValue));
+    });
+  }
+  getImageSource() {
+    const {
+      listing
+    } = this.props;
+    if (!listing || !listing.fields) {
+      return null;
+    }
+    const imageField = listing.fields[values.mandatoryFields.featureImage];
+    if (!imageField) {
+      return null;
+    }
+
+    // Parse the image field value
+    if (typeof imageField === "string") {
+      return imageField;
+    }
+    return (imageField === null || imageField === void 0 ? void 0 : imageField.uri) || (imageField === null || imageField === void 0 ? void 0 : imageField.url) || null;
+  }
+  getTitle() {
+    const {
+      listing
+    } = this.props;
+    if (!listing || !listing.fields) {
+      return values.labels.defaultTitle;
+    }
+    return listing.fields[values.mandatoryFields.title] || values.labels.defaultTitle;
+  }
+  render() {
+    const {
+      listing
+    } = this.props;
+    const imageSource = this.getImageSource();
+    const title = this.getTitle();
+    if (!listing || !listing.fields) {
+      return /*#__PURE__*/React.createElement(View, {
+        style: styles.centerContainer
+      }, /*#__PURE__*/React.createElement(Text, {
+        style: styles.errorText
+      }, "Item not found"));
+    }
+    return /*#__PURE__*/React.createElement(KeyboardAvoidingView, {
+      behavior: Platform.OS === "ios" && "padding",
+      style: {
+        position: "relative",
+        flex: 1,
+        backgroundColor: Colours.BACKGROUND_WHITE || "#fff"
+      }
+    }, /*#__PURE__*/React.createElement(View, {
+      style: styles.backButton
+    }, /*#__PURE__*/React.createElement(View, {
+      style: styles.headerContent
+    }, /*#__PURE__*/React.createElement(Components.BackButton, {
+      onPress: this.onPressBack,
+      style: {
+        marginLeft: 16
+      }
+    }))), /*#__PURE__*/React.createElement(ScrollView, {
+      style: {
+        backgroundColor: Colours.BACKGROUND_WHITE || "#fff"
+      },
+      keyboardShouldPersistTaps: "always",
+      ref: ref => {
+        this.scrollView = ref;
+      }
+    }, /*#__PURE__*/React.createElement(View, {
+      style: [styles.mainHeader]
+    }, imageSource ? /*#__PURE__*/React.createElement(TouchableOpacity, {
+      onPress: () => this.openImagePopup(0),
+      activeOpacity: 0.9
+    }, /*#__PURE__*/React.createElement(Components.AutoOffsetImage, {
+      uri: imageSource,
+      height: CARD_IMAGE_HEIGHT,
+      width: SCREEN_WIDTH
+    })) : /*#__PURE__*/React.createElement(View, {
+      style: [styles.grayPlaceholder, {
+        height: CARD_IMAGE_HEIGHT,
+        width: SCREEN_WIDTH
+      }]
+    }), /*#__PURE__*/React.createElement(LinearGradient, {
+      style: styles.gradientOverlay,
+      colors: ["rgba(0,0,0,0.7)", COLOUR_TRANSPARENT],
+      start: {
+        x: 0,
+        y: 0
+      },
+      end: {
+        x: 0,
+        y: 1
+      },
+      locations: [0, 0.5]
+    })), /*#__PURE__*/React.createElement(View, {
+      style: {
+        paddingHorizontal: 16
+      }
+    }, /*#__PURE__*/React.createElement(View, {
+      style: styles.titleContainer
+    }, /*#__PURE__*/React.createElement(Text, {
+      style: styles.eventTitle
+    }, title))), /*#__PURE__*/React.createElement(View, {
+      style: {
+        minHeight: SCREEN_HEIGHT - CARD_IMAGE_HEIGHT - 56
+      }
+    }, this.renderFields())), this.state.showImagePopup && /*#__PURE__*/React.createElement(Components.ImagePopup, {
+      visible: this.state.showImagePopup,
+      images: this.state.allImages,
+      index: this.state.selectedImageIndex,
+      onClose: this.closeImagePopup
+    }));
+  }
+}
+const styles = StyleSheet.create({
+  backButton: {
+    position: "absolute",
+    left: 0,
+    top: 0,
+    zIndex: 10,
+    elevation: 10,
+    height: StatusBarHeight(70)
+  },
+  headerContent: {
+    alignSelf: "stretch",
+    flexDirection: "row",
+    flex: 1,
+    paddingTop: StatusBarHeight(12)
+  },
+  image: {
+    backgroundColor: Colours.BACKGROUND_WHITE || "#fff",
+    position: "relative",
+    width: undefined,
+    height: undefined,
+    flex: 1
+  },
+  mainHeader: {
+    position: "relative",
+    height: CARD_IMAGE_HEIGHT,
+    width: SCREEN_WIDTH
+  },
+  gradientOverlay: {
+    flex: 1
+  },
+  // Field container and spacing
+  fieldContainer: {
+    paddingHorizontal: 16,
+    marginVertical: 12
+  },
+  // Field labels/captions
+  fieldLabel: {
+    fontFamily: "sf-regular",
+    fontSize: 11,
+    color: TEXT_MID,
+    marginBottom: 6,
+    textTransform: "uppercase",
+    letterSpacing: 1.2,
+    alignSelf: "center",
+    textAlign: "center",
+    paddingHorizontal: 8,
+    paddingVertical: 4,
+    backgroundColor: "rgba(0,0,0,0.03)",
+    borderRadius: 12,
+    maxWidth: "80%"
+  },
+  // Field type styles
+  bodyText: {
+    fontFamily: "sf-regular",
+    fontSize: 16,
+    color: TEXT_DARK,
+    lineHeight: 22
+  },
+  titleText: {
+    fontFamily: "sf-semibold",
+    fontSize: 16,
+    fontWeight: "600",
+    color: TEXT_DARK
+  },
+  descriptionText: {
+    fontFamily: "sf-regular",
+    fontSize: 16,
+    color: TEXT_DARK,
+    lineHeight: 24
+  },
+  numberText: {
+    fontFamily: "sf-medium",
+    fontSize: 16,
+    fontWeight: "500",
+    color: TEXT_DARK
+  },
+  // Link styles
+  linkContainer: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingVertical: 4
+  },
+  linkText: {
+    fontFamily: "sf-medium",
+    fontSize: 16,
+    textDecorationLine: "underline"
+  },
+  // Date styles
+  dateContainer: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingVertical: 4
+  },
+  // Image styles
+  inlineImage: {
+    width: "100%",
+    height: 200,
+    borderRadius: 8,
+    marginVertical: 8
+  },
+  imageCaption: {
+    fontFamily: "sf-italic",
+    fontSize: 14,
+    fontStyle: "italic",
+    color: TEXT_MID,
+    marginTop: 4,
+    textAlign: "center"
+  },
+  // CTA styles
+  ctaContainer: {
+    alignItems: "center",
+    justifyContent: "center",
+    paddingVertical: 8
+  },
+  // Section title styles
+  sectionTitle: {
+    fontFamily: "sf-bold",
+    fontSize: 14,
+    fontWeight: "700",
+    color: TEXT_DARK,
+    marginBottom: SPACING.SM
+  },
+  // Icon styles
+  fieldIcon: {
+    marginRight: 8
+  },
+  // Legacy styles (kept for compatibility)
+  section: {
+    paddingVertical: 16
+  },
+  divider: {
+    height: 1,
+    backgroundColor: LINEGREY,
+    marginVertical: 8,
+    marginHorizontal: 16
+  },
+  facilityDetailTitle: {
+    fontFamily: "sf-bold",
+    color: TEXT_DARK,
+    fontSize: 14
+  },
+  facilityDetailContent: {
+    fontFamily: "sf-regular",
+    color: TEXT_DARK,
+    fontSize: 16,
+    lineHeight: 22
+  },
+  facilityDetailsContainer: {
+    flex: 1
+  },
+  facilityDetailsTextContainer: {
+    flex: 1,
+    justifyContent: "center"
+  },
+  facilityDetailContainer: {
+    marginTop: 16,
+    flexDirection: "row"
+  },
+  facilityDetailTitleContainer: {
+    width: 100,
+    marginRight: 10
+  },
+  titleContainer: {
+    paddingVertical: 16,
+    paddingTop: 20
+  },
+  eventTitle: {
+    fontFamily: "sf-bold",
+    fontSize: 24,
+    lineHeight: 32,
+    color: TEXT_DARK,
+    backgroundColor: "transparent",
+    flex: 1
+  },
+  textLink: {
+    fontFamily: "sf-medium",
+    fontSize: 16,
+    lineHeight: 22
+  },
+  grayPlaceholder: {
+    backgroundColor: LINEGREY
+  },
+  centerContainer: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    paddingHorizontal: 20
+  },
+  errorText: {
+    fontSize: 16,
+    color: TEXT_MID,
+    textAlign: "center"
+  },
+  filesContainer: {
+    marginVertical: 8
+  }
+});
+const mapStateToProps = (state, ownProps) => {
+  return {
+    colourBrandingMain: Colours.getMainBrandingColourFromState(state),
+    colourBrandingHeader: Colours.getMainBrandingColourFromState(state),
+    featureDefinition: selectFeatureDefinition(state),
+    user: state.user
+  };
+};
+export default connect(mapStateToProps, null, null, {
+  forwardRef: true
+})(FeatureDetailScreen);
+//# sourceMappingURL=FeatureDetailScreen.js.map