@thg-altitude/schemaorg 1.0.32 → 1.0.33

package/.nvmrc

@@ -1 +1 @@
-18.15.0
+22.15.0

package/index.js

@@ -6,8 +6,9 @@ import Organization from './src/components/Organization.astro'
 import ProductCollection from './src/components/ProductCollection.astro'
 import WebSite from './src/components/WebSite.astro'
 import EnhancedProductList from './src/components/EnhancedProductList.astro'
+import Recipe from './src/components/Recipe.astro'
 
-export { 
+export {
     Product,
     EnhancedProduct,
     Breadcrumb,
@@ -15,5 +16,6 @@ export {
     Organization,
     ProductCollection,
     WebSite,
-    EnhancedProductList
+    EnhancedProductList,
+    Recipe
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thg-altitude/schemaorg",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "description": "",
   "main": "index.js",
   "scripts": {

package/src/components/EnhancedProduct.astro

@@ -1,4 +1,6 @@
 ---
+import { mapProductSchemaDataEnhanced } from '../utils/productSchema.js';
+
 const {
   image,
   sku,
@@ -23,8 +25,32 @@ const {
   streetAddress,
   addressLocality,
   postalCode,
+  suggestedAge,
+  suggestedGender,
+  beauty_targetAge,
+  gender,
 } = Astro.props;
 
+// Use the enhanced mapping function to extract data from the full product data
+const mappedData = mapProductSchemaDataEnhanced(Astro.props);
+
+// Extract suggestedGender and suggestedAge using the comprehensive mapping function
+let extractedSuggestedGender = suggestedGender || mappedData.suggestedGender;
+let extractedSuggestedAge = suggestedAge || mappedData.suggestedAge;
+
+// Fallback to the original simple extraction if the mapping didn't find anything
+if (!extractedSuggestedGender && Astro.props.productContent?.propertyNameToValueMap?.gender) {
+  extractedSuggestedGender = Array.isArray(Astro.props.productContent.propertyNameToValueMap.gender)
+    ? Astro.props.productContent.propertyNameToValueMap.gender[0]
+    : Astro.props.productContent.propertyNameToValueMap.gender;
+}
+
+if (!extractedSuggestedAge && Astro.props.productContent?.propertyNameToValueMap?.beauty_targetAge) {
+  extractedSuggestedAge = Array.isArray(Astro.props.productContent.propertyNameToValueMap.beauty_targetAge)
+    ? Astro.props.productContent.propertyNameToValueMap.beauty_targetAge[0]
+    : Astro.props.productContent.propertyNameToValueMap.beauty_targetAge;
+}
+
 let url;
 let schema = null;
 let schemaError = false;
@@ -63,49 +89,258 @@ try {
 }
 
 function generateProductSchema() {
+  const hasMultipleVariants = variants && variants.length > 1;
+  let variantsArray = [];
+
   if (variants && variants.length > 0 && currency) {
-    offersArray = variants
-      .filter((variant) => variant?.sku && variant?.price?.price?.amount)
-      .map((variant) => ({
-        "@type": "Offer",
-        sku: variant.sku.toString(),
-        url:
-          variants.length > 1
-            ? `${pageUrl}?variation=${variant?.sku}`
-            : pageUrl,
-        price: variant.price.price.amount,
-        priceCurrency: currency,
-        itemCondition: "http://schema.org/NewCondition",
-        availability: variant?.inStock
-          ? "https://schema.org/InStock"
-          : "https://schema.org/OutOfStock",
-        ...(variant?.barcode && { gtin13: variant.barcode.toString() }),
-        ...(brand && {
-          seller: {
-            "@type": "Organization",
-            name: brand,
-          },
-        }),
-        priceSpecification: [
-          {
-            "@type": "UnitPriceSpecification",
-            priceCurrency: currency,
-            price: variant.price.price.amount,
-            valueAddedTaxIncluded: true,
-          },
-          ...(variant?.price?.rrp?.amount
-            ? [
+    if (hasMultipleVariants) {
+      // Create individual Product objects for each variant
+      variantsArray = variants
+        .filter((variant) => variant?.sku && variant?.price?.price?.amount)
+        .map((variant) => {
+          // Build variant name with attributes from choices in logical order
+          let variantName = name;
+          const attributes = [];
+          
+          // Extract properties in preferred order: Amount + Weight + Flavor + Size + Color + Material
+          if (variant.choices && variant.choices.length > 0) {
+            // Amount (only if explicitly marked as Amount, not weight-related)
+            const amountChoice = variant.choices.find(c =>
+              c.optionKey === 'Amount' &&
+              c.title &&
+              !c.title.includes('kg') &&
+              !c.title.includes('g') &&
+              !c.title.includes('lb')
+            );
+            if (amountChoice && amountChoice.title) attributes.push(amountChoice.title);
+            
+            // Weight (from Weight optionKey OR size containing weight units)
+            const weightChoice = variant.choices.find(c =>
+              c.optionKey === 'Weight' ||
+              (c.optionKey === 'Size' && c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb'))) ||
+              (c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb')))
+            );
+            if (weightChoice && weightChoice.title) attributes.push(weightChoice.title);
+            
+            // Flavor
+            const flavorChoice = variant.choices.find(c =>
+              c.optionKey === 'Flavour' || c.optionKey === 'Flavor' || c.optionKey === 'Taste'
+            );
+            if (flavorChoice && flavorChoice.title) attributes.push(flavorChoice.title);
+            
+            // Size (excluding weight-related sizes and already processed weight)
+            const sizeChoice = variant.choices.find(c =>
+              c.optionKey === 'Size' &&
+              c.title &&
+              !c.title.includes('kg') &&
+              !c.title.includes('g') &&
+              !c.title.includes('lb') &&
+              c !== weightChoice  // Don't duplicate if already used as weight
+            );
+            if (sizeChoice && sizeChoice.title) attributes.push(sizeChoice.title);
+            
+            // Color
+            const colorChoice = variant.choices.find(c => c.optionKey === 'Color' || c.optionKey === 'Colour' || c.colour);
+            if (colorChoice) {
+              if (colorChoice.colour) attributes.push(colorChoice.colour);
+              else if (colorChoice.title) attributes.push(colorChoice.title);
+            }
+            
+            // Material
+            const materialChoice = variant.choices.find(c => c.optionKey === 'Material');
+            if (materialChoice && materialChoice.title) attributes.push(materialChoice.title);
+          }
+          
+          if (attributes.length > 0) {
+            variantName = `${name} ${attributes.join(' ')}`;
+          }
+          
+          return {
+            "@type": "Product",
+            sku: variant.sku.toString(),
+            name: variantName,
+            ...(description && { description }),
+            ...(imageUrl && { image: imageUrl }),
+            // Extract variant-specific properties from choices using correct schema.org properties
+            ...(variant.choices && variant.choices.some(c => c.optionKey === 'Weight' || (c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb')))) && {
+              weight: variant.choices.find(c => c.optionKey === 'Weight' || (c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb'))))?.title
+            }),
+            ...(variant.choices && variant.choices.some(c => c.optionKey === 'Size' && c.title && !c.title.includes('kg') && !c.title.includes('g') && !c.title.includes('lb')) && {
+              size: variant.choices.find(c => c.optionKey === 'Size' && c.title && !c.title.includes('kg') && !c.title.includes('g') && !c.title.includes('lb'))?.title
+            }),
+            ...(variant.choices && variant.choices.some(c => c.optionKey === 'Color' || c.optionKey === 'Colour' || c.colour) && {
+              color: variant.choices.find(c => c.optionKey === 'Color' || c.optionKey === 'Colour' || c.colour)?.colour ||
+                     variant.choices.find(c => c.optionKey === 'Color' || c.optionKey === 'Colour')?.title
+            }),
+            ...(variant.choices && variant.choices.some(c => c.optionKey === 'Material') && {
+              material: variant.choices.find(c => c.optionKey === 'Material')?.title
+            }),
+            // Handle non-standard properties (amount, flavor) as additionalProperty
+            ...(() => {
+              const additionalProperties = [];
+              
+              // Amount
+              const amountChoice = variant.choices?.find(c => c.optionKey === 'Amount');
+              if (amountChoice?.title) {
+                additionalProperties.push({
+                  "@type": "PropertyValue",
+                  "name": "amount",
+                  "value": amountChoice.title
+                });
+              }
+              
+              // Flavor
+              const flavorChoice = variant.choices?.find(c => c.optionKey === 'Flavour' || c.optionKey === 'Flavor' || c.optionKey === 'Taste');
+              if (flavorChoice?.title) {
+                additionalProperties.push({
+                  "@type": "PropertyValue",
+                  "name": "flavor",
+                  "value": flavorChoice.title
+                });
+              }
+              
+              return additionalProperties.length > 0 ? { additionalProperty: additionalProperties } : {};
+            })(),
+            ...(variant?.barcode && { gtin13: variant.barcode.toString() }),
+            offers: {
+              "@type": "Offer",
+              url: `${pageUrl}?variation=${variant?.sku}`,
+              price: variant.price.price.amount,
+              priceCurrency: currency,
+              itemCondition: "https://schema.org/NewCondition",
+              availability: variant?.inStock
+                ? "https://schema.org/InStock"
+                : "https://schema.org/OutOfStock",
+              ...(brand && {
+                seller: {
+                  "@type": "Organization",
+                  name: brand,
+                },
+              }),
+              priceSpecification: [
                 {
                   "@type": "UnitPriceSpecification",
                   priceCurrency: currency,
-                  price: variant.price.rrp.amount,
+                  price: variant.price.price.amount,
                   valueAddedTaxIncluded: true,
-                  priceType: "https://schema.org/ListPrice",
                 },
-              ]
-            : []),
-        ],
-      }));
+                ...(variant?.price?.rrp?.amount
+                  ? [
+                      {
+                        "@type": "UnitPriceSpecification",
+                        priceCurrency: currency,
+                        price: variant.price.rrp.amount,
+                        valueAddedTaxIncluded: true,
+                        priceType: "https://schema.org/StrikethroughPrice",
+                      },
+                    ]
+                  : []),
+              ],
+            }
+          };
+        });
+    } else {
+      // Single variant - create offers array as before
+      offersArray = variants
+        .filter((variant) => variant?.sku && variant?.price?.price?.amount)
+        .map((variant) => {
+          // Build variant name with attributes from choices in logical order
+          let variantName = name;
+          const attributes = [];
+          
+          // Extract properties in preferred order: Amount + Weight + Flavor + Size + Color + Material
+          if (variant.choices && variant.choices.length > 0) {
+            // Amount (only if explicitly marked as Amount, not weight-related)
+            const amountChoice = variant.choices.find(c =>
+              c.optionKey === 'Amount' &&
+              c.title &&
+              !c.title.includes('kg') &&
+              !c.title.includes('g') &&
+              !c.title.includes('lb')
+            );
+            if (amountChoice && amountChoice.title) attributes.push(amountChoice.title);
+            
+            // Weight (from Weight optionKey OR size containing weight units)
+            const weightChoice = variant.choices.find(c =>
+              c.optionKey === 'Weight' ||
+              (c.optionKey === 'Size' && c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb'))) ||
+              (c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb')))
+            );
+            if (weightChoice && weightChoice.title) attributes.push(weightChoice.title);
+            
+            // Flavor
+            const flavorChoice = variant.choices.find(c =>
+              c.optionKey === 'Flavour' || c.optionKey === 'Flavor' || c.optionKey === 'Taste'
+            );
+            if (flavorChoice && flavorChoice.title) attributes.push(flavorChoice.title);
+            
+            // Size (excluding weight-related sizes and already processed weight)
+            const sizeChoice = variant.choices.find(c =>
+              c.optionKey === 'Size' &&
+              c.title &&
+              !c.title.includes('kg') &&
+              !c.title.includes('g') &&
+              !c.title.includes('lb') &&
+              c !== weightChoice  // Don't duplicate if already used as weight
+            );
+            if (sizeChoice && sizeChoice.title) attributes.push(sizeChoice.title);
+            
+            // Color
+            const colorChoice = variant.choices.find(c => c.optionKey === 'Color' || c.optionKey === 'Colour' || c.colour);
+            if (colorChoice) {
+              if (colorChoice.colour) attributes.push(colorChoice.colour);
+              else if (colorChoice.title) attributes.push(colorChoice.title);
+            }
+            
+            // Material
+            const materialChoice = variant.choices.find(c => c.optionKey === 'Material');
+            if (materialChoice && materialChoice.title) attributes.push(materialChoice.title);
+          }
+          
+          if (attributes.length > 0) {
+            variantName = `${name} ${attributes.join(' ')}`;
+          }
+          
+          return {
+            "@type": "Offer",
+            name: variantName,
+            sku: variant.sku.toString(),
+            url: pageUrl,
+            price: variant.price.price.amount,
+            priceCurrency: currency,
+            itemCondition: "https://schema.org/NewCondition",
+            availability: variant?.inStock
+              ? "https://schema.org/InStock"
+              : "https://schema.org/OutOfStock",
+            ...(variant?.barcode && { gtin13: variant.barcode.toString() }),
+            ...(brand && {
+              seller: {
+                "@type": "Organization",
+                name: brand,
+              },
+            }),
+            priceSpecification: [
+              {
+                "@type": "UnitPriceSpecification",
+                priceCurrency: currency,
+                price: variant.price.price.amount,
+                valueAddedTaxIncluded: true,
+              },
+              ...(variant?.price?.rrp?.amount
+                ? [
+                    {
+                      "@type": "UnitPriceSpecification",
+                      priceCurrency: currency,
+                      price: variant.price.rrp.amount,
+                      valueAddedTaxIncluded: true,
+                      priceType: "https://schema.org/StrikethroughPrice",
+                    },
+                  ]
+                : []),
+            ],
+          };
+        });
+    }
   }
 
   const category =
@@ -116,38 +351,166 @@ function generateProductSchema() {
   const reviewsArray = generateReviewsSchema();
 
   if (name && sku) {
-    const productSchema = {
-      "@type": "Product",
-      "@id": pageUrl,
-      url: pageUrl,
-      sku: sku.toString(),
-      name: name,
-      ...(gtin13 && { gtin13: gtin13.toString() }),
-      ...(description && { description }),
-      ...(imageUrl && { image: imageUrl }),
-      ...(brand && {
-        brand: {
-          "@type": "Brand",
-          name: brand,
-        },
-      }),
-      ...(reviewsCount > 0 &&
-        reviewsAverage && {
-          aggregateRating: {
-            "@type": "AggregateRating",
-            ratingValue: reviewsAverage,
-            reviewCount: reviewsCount,
-            bestRating: 5,
-            worstRating: 1,
+    const hasMultipleVariants = variants && variants.length > 1;
+    
+    if (hasMultipleVariants) {
+      // Determine what properties vary between variants
+      const variesBy = [];
+      
+      // Check what attributes exist across variants based on choices using correct schema.org properties
+      if (variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Weight' || (c.title && (c.title.includes('kg') || c.title.includes('g') || c.title.includes('lb')))))) {
+        variesBy.push("https://schema.org/weight");
+      }
+      if (variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Size' && c.title && !c.title.includes('kg') && !c.title.includes('g') && !c.title.includes('lb')))) {
+        variesBy.push("https://schema.org/size");
+      }
+      if (variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Color' || c.optionKey === 'Colour' || c.colour))) {
+        variesBy.push("https://schema.org/color");
+      }
+      if (variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Material'))) {
+        variesBy.push("https://schema.org/material");
+      }
+      
+      // For non-standard properties like amount and flavor, use additionalProperty
+      if (variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Amount')) ||
+          variants.some(v => v.choices && v.choices.some(c => c.optionKey === 'Flavour' || c.optionKey === 'Flavor' || c.optionKey === 'Taste'))) {
+        variesBy.push("https://schema.org/additionalProperty");
+      }
+
+      const productGroupSchema = {
+        "@type": "ProductGroup",
+        "@id": pageUrl,
+        url: pageUrl,
+        name: name,
+        productGroupID: sku.toString(),
+        ...(gtin13 && { gtin13: gtin13.toString() }),
+        ...(description && { description }),
+        ...(imageUrl && { image: imageUrl }),
+        ...(brand && {
+          brand: {
+            "@type": "Brand",
+            name: brand,
           },
         }),
-      ...(reviewsArray && reviewsArray.length > 0 && { review: reviewsArray }),
-      ...(category && { category }),
-      ...(keywords && { keywords }),
-      ...(offersArray.length > 0 && { offers: offersArray }),
-    };
+        ...(variesBy.length > 0 && { variesBy }),
+        hasVariant: variantsArray,
+        ...(reviewsCount > 0 &&
+          reviewsAverage && {
+            aggregateRating: {
+              "@type": "AggregateRating",
+              ratingValue: reviewsAverage,
+              reviewCount: reviewsCount,
+              bestRating: 5,
+              worstRating: 1,
+            },
+          }),
+        ...(reviewsArray && reviewsArray.length > 0 && { review: reviewsArray }),
+        ...(category && { category }),
+        ...(keywords && { keywords }),
+        // Handle custom properties as additionalProperty
+        ...(() => {
+          const additionalProperties = [];
+          if (extractedSuggestedGender) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "suggestedGender",
+              "value": extractedSuggestedGender
+            });
+          }
+          if (extractedSuggestedAge) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "suggestedAge",
+              "value": extractedSuggestedAge
+            });
+          }
+          if (beauty_targetAge) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "targetAge",
+              "value": beauty_targetAge
+            });
+          }
+          if (gender) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "GenderType",
+              "value": gender
+            });
+          }
+          return additionalProperties.length > 0 ? { additionalProperty: additionalProperties } : {};
+        })(),
+      };
 
-    graphArray.push(productSchema);
+      graphArray.push(productGroupSchema);
+    } else {
+      // Single product schema as before
+      const productSchema = {
+        "@type": "Product",
+        "@id": pageUrl,
+        url: pageUrl,
+        sku: sku.toString(),
+        name: name,
+        ...(gtin13 && { gtin13: gtin13.toString() }),
+        ...(description && { description }),
+        ...(imageUrl && { image: imageUrl }),
+        ...(brand && {
+          brand: {
+            "@type": "Brand",
+            name: brand,
+          },
+        }),
+        ...(reviewsCount > 0 &&
+          reviewsAverage && {
+            aggregateRating: {
+              "@type": "AggregateRating",
+              ratingValue: reviewsAverage,
+              reviewCount: reviewsCount,
+              bestRating: 5,
+              worstRating: 1,
+            },
+          }),
+        ...(reviewsArray && reviewsArray.length > 0 && { review: reviewsArray }),
+        ...(category && { category }),
+        ...(keywords && { keywords }),
+        // Handle custom properties as additionalProperty
+        ...(() => {
+          const additionalProperties = [];
+          if (extractedSuggestedGender) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "suggestedGender",
+              "value": extractedSuggestedGender
+            });
+          }
+          if (extractedSuggestedAge) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "suggestedAge",
+              "value": extractedSuggestedAge
+            });
+          }
+          if (beauty_targetAge) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "beauty_targetAge",
+              "value": beauty_targetAge
+            });
+          }
+          if (gender) {
+            additionalProperties.push({
+              "@type": "PropertyValue",
+              "name": "gender",
+              "value": gender
+            });
+          }
+          return additionalProperties.length > 0 ? { additionalProperty: additionalProperties } : {};
+        })(),
+        ...(offersArray.length > 0 && { offers: offersArray }),
+      };
+
+      graphArray.push(productSchema);
+    }
   }
 }
 
@@ -281,6 +644,34 @@ function generateReviewsSchema() {
 
 {
   schema && !schemaError && (
-    <script type="application/ld+json" set:html={JSON.stringify(schema)} />
+    <script type="application/ld+json" set:html={(() => {
+      // Clean the schema object by removing undefined, null, and empty values
+      function cleanObject(obj) {
+        if (obj === null || obj === undefined || obj === '') {
+          return undefined;
+        }
+        
+        if (Array.isArray(obj)) {
+          const cleaned = obj.map(cleanObject).filter(item => item !== undefined);
+          return cleaned.length > 0 ? cleaned : undefined;
+        }
+        
+        if (typeof obj === 'object' && obj !== null) {
+          const cleaned = {};
+          for (const [key, value] of Object.entries(obj)) {
+            const cleanedValue = cleanObject(value);
+            if (cleanedValue !== undefined) {
+              cleaned[key] = cleanedValue;
+            }
+          }
+          return Object.keys(cleaned).length > 0 ? cleaned : undefined;
+        }
+        
+        return obj;
+      }
+      
+      const cleanedSchema = cleanObject(schema);
+      return cleanedSchema ? JSON.stringify(cleanedSchema, null, 2) : '{}';
+    })()} />
   )
 }

package/src/components/Product.astro

@@ -1,70 +1,345 @@
 ---
-import { stripHtml } from '@thg-altitude/utils'
+import { mapProductSchemaData, stripHtml } from '../utils/productSchema.js';
+
+// Use the mapping function to extract data from the full product data
+const mappedData = mapProductSchemaData(Astro.props);
+
+// Extract suggestedGender and suggestedAge using the comprehensive mapping function
+let suggestedGender = Astro.props.suggestedGender || mappedData.suggestedGender;
+let suggestedAge = Astro.props.suggestedAge || mappedData.suggestedAge;
+
+// Fallback to the original simple extraction if the mapping didn't find anything
+if (!suggestedGender && Astro.props.productContent?.propertyNameToValueMap?.gender) {
+  suggestedGender = Array.isArray(Astro.props.productContent.propertyNameToValueMap.gender)
+    ? Astro.props.productContent.propertyNameToValueMap.gender[0]
+    : Astro.props.productContent.propertyNameToValueMap.gender;
+}
+
+if (!suggestedAge && Astro.props.productContent?.propertyNameToValueMap?.beauty_targetAge) {
+  suggestedAge = Array.isArray(Astro.props.productContent.propertyNameToValueMap.beauty_targetAge)
+    ? Astro.props.productContent.propertyNameToValueMap.beauty_targetAge[0]
+    : Astro.props.productContent.propertyNameToValueMap.beauty_targetAge;
+}
+
 let url = import.meta.env.DEV
     ? Astro.url.origin
     : `${Astro.request.headers.get(
         'X-forwarded-Proto'
       )}://${Astro.request.headers.get('X-forwarded-Host')?.split(', ')[0]}`
+// Check if we have multiple variants to determine if we need ProductGroup
+const hasMultipleVariants = Astro.props.variants && Astro.props.variants.length > 1;
+
+let variantsArray = []
 let offersArray = []
-Astro.props.variants?.forEach((variant)=>{
-  offersArray.push({
-    "@type": "Offer",
-    "sku": variant.sku.toString(),
-    "url": Astro.props.variants.length > 1 ? `${url}${Astro.props.url}?variation=${variant?.sku}`: `${url}${Astro.props.url}`,
-    "price": variant?.price?.price?.amount,
-    "priceCurrency": Astro.props.currency,
-    "itemCondition": "http://schema.org/NewCondition",
-    "availability": variant?.inStock ? "https://schema.org/InStock" : "https://schema.org/OutOfStock"
-  })
-})
+
+if (hasMultipleVariants) {
+  // Create individual Product objects for each variant
+  if (Array.isArray(Astro.props.variants)) {
+    Astro.props.variants.forEach((variant) => {
+      if (variant && typeof variant === 'object' && variant.sku) {
+        // Build variant name with attributes in logical order: Name + Weight + Flavor + Size + Color + Material
+        let variantName = Astro.props.name || "";
+        const attributes = [];
+        
+        // Check for amount/quantity first
+        if (variant.amount) attributes.push(variant.amount);
+        
+        // Check for weight in different possible property names
+        if (variant.weight) attributes.push(variant.weight);
+        else if (variant.size && variant.size.includes('kg')) attributes.push(variant.size);
+        else if (variant.size && variant.size.includes('g')) attributes.push(variant.size);
+        
+        // Check for flavor in different possible property names
+        if (variant.flavor) attributes.push(variant.flavor);
+        else if (variant.flavour) attributes.push(variant.flavour);
+        else if (variant.taste) attributes.push(variant.taste);
+        else if (variant.name && variant.name !== Astro.props.name) {
+          // If variant has its own name that's different from product name, use it as flavor
+          const variantSpecificName = variant.name.replace(Astro.props.name, '').trim();
+          if (variantSpecificName) attributes.push(variantSpecificName);
+        }
+        
+        // Add other attributes
+        if (variant.size && !variant.size.includes('kg') && !variant.size.includes('g')) attributes.push(variant.size);
+        if (variant.color) attributes.push(variant.color);
+        if (variant.material) attributes.push(variant.material);
+        
+        if (attributes.length > 0 && Astro.props.name) {
+          variantName = `${Astro.props.name} ${attributes.join(' ')}`;
+        }
+
+        const variantObj = {
+          "@type": "Product",
+          "sku": variant.sku.toString()
+        };
+        
+        if (variantName) variantObj.name = variantName;
+        if (Astro.props.description) variantObj.description = Astro.props.description;
+        if ((variant.image || Astro.props.image) && import.meta.env.IMAGE_PROXY_URL) {
+          variantObj.image = `${import.meta.env.IMAGE_PROXY_URL}?url=${variant.image || Astro.props.image}&format=webp&width=1500&height=1500&fit=cover`;
+        }
+        // Use correct schema.org properties
+        if (variant.color) variantObj.color = variant.color;
+        if (variant.size) variantObj.size = variant.size;
+        if (variant.material) variantObj.material = variant.material;
+        if (variant.weight) variantObj.weight = variant.weight;
+        
+        // Handle amount and flavor as additionalProperty since they're not standard schema.org properties
+        const additionalProperties = [];
+        
+        if (variant.amount) {
+          additionalProperties.push({
+            "@type": "PropertyValue",
+            "name": "amount",
+            "value": variant.amount
+          });
+        }
+        
+        // Handle flavor with multiple possible property names
+        let flavorValue = null;
+        if (variant.flavor) flavorValue = variant.flavor;
+        else if (variant.flavour) flavorValue = variant.flavour;
+        else if (variant.taste) flavorValue = variant.taste;
+        
+        if (flavorValue) {
+          additionalProperties.push({
+            "@type": "PropertyValue",
+            "name": "flavor",
+            "value": flavorValue
+          });
+        }
+        
+        if (additionalProperties.length > 0) {
+          variantObj.additionalProperty = additionalProperties;
+        }
+        if (variant.gtin13) variantObj.gtin13 = variant.gtin13.toString();
+        
+        const offerObj = {
+          "@type": "Offer",
+          "url": `${url}${Astro.props.url || ""}?variation=${variant.sku}`,
+          "itemCondition": "https://schema.org/NewCondition",
+          "availability": variant.inStock ? "https://schema.org/InStock" : "https://schema.org/OutOfStock"
+        };
+        
+        if (variant?.price?.price?.amount) offerObj.price = variant.price.price.amount;
+        if (Astro.props.currency) offerObj.priceCurrency = Astro.props.currency;
+        
+        variantObj.offers = offerObj;
+        variantsArray.push(variantObj);
+      }
+    });
+  }
+} else {
+  // Single variant - create offers array as before
+  if (Array.isArray(Astro.props.variants)) {
+    Astro.props.variants.forEach((variant) => {
+      if (variant && typeof variant === 'object' && variant.sku) {
+        const offerObj = {
+          "@type": "Offer",
+          "sku": variant.sku.toString(),
+          "url": `${url}${Astro.props.url || ""}`,
+          "itemCondition": "https://schema.org/NewCondition",
+          "availability": variant.inStock ? "https://schema.org/InStock" : "https://schema.org/OutOfStock"
+        };
+        
+        if (variant?.price?.price?.amount) offerObj.price = variant.price.price.amount;
+        if (Astro.props.currency) offerObj.priceCurrency = Astro.props.currency;
+        
+        offersArray.push(offerObj);
+      }
+    });
+  }
+}
 
 let reviewsArray = []
-Astro.props.reviews?.forEach((review)=>{
-  reviewsArray.push({
-    "@type": "Review",
-    itemReviewed: {
-      "@id": Astro.props.sku.toString(),
-      name: Astro.props.name,
-    },
-    reviewRating: {
-      "@type": "Rating",
-      ratingValue: review?.elements?.[0]?.score,
-      bestRating: "5",
-    },
-    author: {
-      "@type": "Person",
-      name: stripHtml(review?.authorName),
-    },
-    datePublished: review?.posted,
-    reviewBody: stripHtml(review?.elements?.[1]?.value),
+if (Astro.props.reviews && Array.isArray(Astro.props.reviews)) {
+  Astro.props.reviews.forEach((review)=>{
+    if (review && typeof review === 'object') {
+      const reviewObj = {
+        "@type": "Review",
+        "itemReviewed": {
+          "@id": Astro.props.sku ? Astro.props.sku.toString() : "",
+          "name": Astro.props.name || ""
+        },
+        "reviewRating": {
+          "@type": "Rating",
+          "bestRating": "5"
+        },
+        "author": {
+          "@type": "Person"
+        }
+      };
+      
+      if (review?.elements?.[0]?.score) reviewObj.reviewRating.ratingValue = review.elements[0].score;
+      if (review?.authorName) reviewObj.author.name = stripHtml(review.authorName);
+      if (review?.posted) reviewObj.datePublished = review.posted;
+      if (review?.elements?.[1]?.value) reviewObj.reviewBody = stripHtml(review.elements[1].value);
+      
+      reviewsArray.push(reviewObj);
+    }
   });
-});
+}
 
-let aggregateRating = Astro.props.reviewsCount > 0 ? {
-	"@type": "AggregateRating",
-	"ratingValue": Astro.props.reviewsAverage,
-	"reviewCount": Astro.props.reviewsCount,
-  bestRating: 5,
-  worstRating: 1,
-} : undefined
+let aggregateRating = undefined;
+if (Astro.props.reviewsCount > 0) {
+  aggregateRating = {
+    "@type": "AggregateRating",
+    "bestRating": 5,
+    "worstRating": 1
+  };
+  
+  if (Astro.props.reviewsAverage) aggregateRating.ratingValue = Astro.props.reviewsAverage;
+  if (Astro.props.reviewsCount) aggregateRating.reviewCount = Astro.props.reviewsCount;
+}
 
-let schema = {
-    "@type": "Product",
+let schema;
+
+if (hasMultipleVariants) {
+  // Determine what properties vary between variants
+  const variesBy = [];
+  
+  // Check what attributes exist across variants - ensure variants is an array
+  if (Array.isArray(Astro.props.variants)) {
+    if (Astro.props.variants.some(v => v && v.weight)) variesBy.push("https://schema.org/weight");
+    if (Astro.props.variants.some(v => v && v.size)) variesBy.push("https://schema.org/size");
+    if (Astro.props.variants.some(v => v && v.color)) variesBy.push("https://schema.org/color");
+    if (Astro.props.variants.some(v => v && v.material)) variesBy.push("https://schema.org/material");
+    
+    // For non-standard properties like amount and flavor, we use additionalProperty
+    // but still include them in variesBy for semantic meaning
+    if (Astro.props.variants.some(v => v && v.amount)) variesBy.push("https://schema.org/additionalProperty");
+    
+    // Check for flavor with multiple possible property names
+    if (Astro.props.variants.some(v => v && (v.flavor || v.flavour || v.taste))) {
+      // Only add additionalProperty once even if we have multiple non-standard properties
+      if (!variesBy.includes("https://schema.org/additionalProperty")) {
+        variesBy.push("https://schema.org/additionalProperty");
+      }
+    }
+  }
+
+  schema = {
+    "@type": "ProductGroup",
     "@context": "https://schema.org",
-    "@id": Astro.props.sku.toString(),
-    "sku": Astro.props.sku.toString(),
-    "name": Astro.props.name,
-    "description": Astro.props.description,
-    "image": `${import.meta.env.IMAGE_PROXY_URL}?url=${Astro.props.image}&format=webp&width=1500&height=1500&fit=cover`,
-    "brand": {
+    "@id": Astro.props.sku ? Astro.props.sku.toString() : "",
+    "url": `${url}${Astro.props.url || ""}`,
+    "productGroupID": Astro.props.sku ? Astro.props.sku.toString() : "",
+    "hasVariant": variantsArray
+  };
+  
+  if (Astro.props.name) schema.name = Astro.props.name;
+  if (Astro.props.description) schema.description = Astro.props.description;
+  if (Astro.props.image && import.meta.env.IMAGE_PROXY_URL) {
+    schema.image = `${import.meta.env.IMAGE_PROXY_URL}?url=${Astro.props.image}&format=webp&width=1500&height=1500&fit=cover`;
+  }
+  if (Astro.props.brand) {
+    schema.brand = {
       "@type": "Brand",
-      "name": Astro.props.brand,
-    },
-    "aggregateRating": aggregateRating,
-    "review": reviewsArray.length ? reviewsArray : null,
+      "name": Astro.props.brand
+    };
+  }
+  if (variesBy.length > 0) schema.variesBy = variesBy;
+  
+  // Handle custom properties as additionalProperty (schema.org compliant)
+  const additionalProperties = [];
+  if (suggestedGender) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "suggestedGender",
+      "value": suggestedGender
+    });
+  }
+  if (suggestedAge) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "suggestedAge",
+      "value": suggestedAge
+    });
+  }
+  if (Astro.props.beauty_targetAge) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "targetAge",
+      "value": Astro.props.beauty_targetAge
+    });
+  }
+  if (Astro.props.gender) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "GenderType",
+      "value": Astro.props.gender
+    });
+  }
+  if (additionalProperties.length > 0) {
+    schema.additionalProperty = additionalProperties;
+  }
+  if (aggregateRating) schema.aggregateRating = aggregateRating;
+  if (reviewsArray.length > 0) schema.review = reviewsArray;
+} else {
+  // Single product schema as before
+  schema = {
+    "@type": "Product",
+    "@context": "https://schema.org",
+    "@id": Astro.props.sku ? Astro.props.sku.toString() : "",
+    "sku": Astro.props.sku ? Astro.props.sku.toString() : "",
     "offers": offersArray
-};
+  };
+  
+  if (Astro.props.name) schema.name = Astro.props.name;
+  if (Astro.props.description) schema.description = Astro.props.description;
+  if (Astro.props.image && import.meta.env.IMAGE_PROXY_URL) {
+    schema.image = `${import.meta.env.IMAGE_PROXY_URL}?url=${Astro.props.image}&format=webp&width=1500&height=1500&fit=cover`;
+  }
+  if (Astro.props.brand) {
+    schema.brand = {
+      "@type": "Brand",
+      "name": Astro.props.brand
+    };
+  }
+  
+  // Handle custom properties as additionalProperty (schema.org compliant)
+  const additionalProperties = [];
+  if (suggestedGender) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "suggestedGender",
+      "value": suggestedGender
+    });
+  }
+  if (suggestedAge) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "suggestedAge",
+      "value": suggestedAge
+    });
+  }
+  if (Astro.props.beauty_targetAge) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "beauty_targetAge",
+      "value": Astro.props.beauty_targetAge
+    });
+  }
+  if (Astro.props.gender) {
+    additionalProperties.push({
+      "@type": "PropertyValue",
+      "name": "gender",
+      "value": Astro.props.gender
+    });
+  }
+  if (additionalProperties.length > 0) {
+    schema.additionalProperty = additionalProperties;
+  }
+  if (aggregateRating) schema.aggregateRating = aggregateRating;
+  if (reviewsArray.length > 0) schema.review = reviewsArray;
+}
 
 ---
 
-<script type="application/ld+json" set:html={JSON.stringify(schema)}></script>
+<script type="application/ld+json" set:html={JSON.stringify(schema, (key, value) => {
+  // Filter out undefined, null, and empty string values
+  if (value === undefined || value === null || value === '') {
+    return undefined;
+  }
+  return value;
+})}></script>

package/src/components/Recipe.astro

@@ -0,0 +1,175 @@
+---
+const { contents, author, image, name, title } = Astro.props
+
+const recipeDetails = contents?.find(
+  (obj) => obj.type === 'recipeDetails'
+)?.props
+const hasRecipe =
+  contents?.find((obj) => obj.type?.includes('recipe')) !== undefined
+
+const recipeIngredientsData = contents?.find((obj) => obj.type === 'recipeIngredients')?.props
+const recipeInstructionsData = contents?.find((obj) => obj.type === 'recipeInstructions')?.props
+const recipeNutritionData = contents?.find((obj) => obj.type === 'recipeNutrition')?.props
+
+// Build recipe schema data
+const recipeSchemaData = {}
+
+// Add basic recipe information - try multiple possible property names
+// Check props first, then recipeDetails
+if (name || title || recipeDetails?.title || recipeDetails?.name) {
+  recipeSchemaData.name = name || title || recipeDetails.title || recipeDetails.name
+}
+if (recipeDetails?.description || recipeDetails?.summary) {
+  recipeSchemaData.description = recipeDetails.description || recipeDetails.summary
+}
+if (recipeDetails?.cookTime || recipeDetails?.cookingTime || recipeDetails?.cook_time) {
+  recipeSchemaData.cookTime = recipeDetails.cookTime || recipeDetails.cookingTime || recipeDetails.cook_time
+}
+if (recipeDetails?.prepTime || recipeDetails?.preparationTime || recipeDetails?.prep_time) {
+  recipeSchemaData.prepTime = recipeDetails.prepTime || recipeDetails.preparationTime || recipeDetails.prep_time
+}
+if (recipeDetails?.servings || recipeDetails?.serves || recipeDetails?.yield) {
+  recipeSchemaData.recipeYield = recipeDetails.servings || recipeDetails.serves || recipeDetails.yield
+}
+
+// Add ingredients - convert to simple string array
+if (recipeIngredientsData) {
+  let ingredients = null
+  
+  // Try different property names
+  ingredients = recipeIngredientsData.ingredients ||
+               recipeIngredientsData.items ||
+               recipeIngredientsData.list ||
+               recipeIngredientsData.ingredientList
+  
+  // If it's an array directly
+  if (!ingredients && Array.isArray(recipeIngredientsData)) {
+    ingredients = recipeIngredientsData
+  }
+  
+  // If it's an object with nested data
+  if (!ingredients && typeof recipeIngredientsData === 'object') {
+    // Try to find any array property
+    for (const key in recipeIngredientsData) {
+      if (Array.isArray(recipeIngredientsData[key])) {
+        ingredients = recipeIngredientsData[key]
+        break
+      }
+    }
+  }
+  
+  if (ingredients && Array.isArray(ingredients) && ingredients.length > 0) {
+    // Convert ingredient objects to strings
+    recipeSchemaData.recipeIngredient = ingredients.map(ingredient => {
+      if (typeof ingredient === 'string') {
+        return ingredient
+      } else if (ingredient?.ingredient) {
+        // Combine quantity, unit, and ingredient into a string
+        const parts = []
+        if (ingredient.quantity) parts.push(ingredient.quantity)
+        if (ingredient.unit) parts.push(ingredient.unit)
+        if (ingredient.ingredient) parts.push(ingredient.ingredient)
+        return parts.join(' ')
+      } else if (ingredient?.name) {
+        return ingredient.name
+      }
+      return String(ingredient)
+    })
+  }
+}
+
+// Add instructions - convert to simple string array
+if (recipeInstructionsData) {
+  let instructions = null
+  
+  // Try different property names
+  instructions = recipeInstructionsData.instructions ||
+                recipeInstructionsData.steps ||
+                recipeInstructionsData.directions ||
+                recipeInstructionsData.method ||
+                recipeInstructionsData.stepList
+  
+  // If it's an array directly
+  if (!instructions && Array.isArray(recipeInstructionsData)) {
+    instructions = recipeInstructionsData
+  }
+  
+  // If it's an object with nested data
+  if (!instructions && typeof recipeInstructionsData === 'object') {
+    // Try to find any array property
+    for (const key in recipeInstructionsData) {
+      if (Array.isArray(recipeInstructionsData[key])) {
+        instructions = recipeInstructionsData[key]
+        break
+      }
+    }
+  }
+  
+  if (instructions && Array.isArray(instructions) && instructions.length > 0) {
+    // Convert instruction objects to strings
+    recipeSchemaData.recipeInstructions = instructions.map(instruction => {
+      if (typeof instruction === 'string') {
+        return instruction
+      } else if (instruction?.instruction) {
+        // Strip HTML tags from instruction text
+        return instruction.instruction.replace(/<[^>]*>/g, '')
+      } else if (instruction?.text) {
+        return instruction.text.replace(/<[^>]*>/g, '')
+      }
+      return String(instruction).replace(/<[^>]*>/g, '')
+    })
+  }
+}
+
+// Add nutrition information - map to correct Schema.org property names
+if (recipeNutritionData?.nutritionalInformation || recipeNutritionData) {
+  const nutritionData = recipeNutritionData?.nutritionalInformation || recipeNutritionData
+  
+  const nutrition = {
+    '@type': 'NutritionInformation'
+  }
+  
+  // Map nutrition properties to Schema.org names
+  if (nutritionData.calories) nutrition.calories = nutritionData.calories
+  if (nutritionData.totalFat) nutrition.fatContent = nutritionData.totalFat
+  if (nutritionData.saturatedFat) nutrition.saturatedFatContent = nutritionData.saturatedFat
+  if (nutritionData.transFat) nutrition.transFatContent = nutritionData.transFat
+  if (nutritionData.cholesterol) nutrition.cholesterolContent = nutritionData.cholesterol
+  if (nutritionData.sodium) nutrition.sodiumContent = nutritionData.sodium
+  if (nutritionData.totalCarbohydrates) nutrition.carbohydrateContent = nutritionData.totalCarbohydrates
+  if (nutritionData.dietaryFiber) nutrition.fiberContent = nutritionData.dietaryFiber
+  if (nutritionData.sugar) nutrition.sugarContent = nutritionData.sugar
+  if (nutritionData.protein) nutrition.proteinContent = nutritionData.protein
+  
+  recipeSchemaData.nutrition = nutrition
+}
+
+// Add image if available
+if (image?.mediaItemUrl) {
+  recipeSchemaData.image = image.mediaItemUrl
+}
+
+// Add author if available
+if (author?.name) {
+  recipeSchemaData.author = {
+    '@type': 'Person',
+    name: author.name
+  }
+}
+
+const recipeSchema = {
+  '@context': 'https://schema.org',
+  '@type': 'Recipe',
+  ...recipeSchemaData
+}
+---
+
+{
+  hasRecipe && (
+    <script
+      is:inline
+      type='application/ld+json'
+      set:html={JSON.stringify(recipeSchema)}
+    />
+  )
+}

package/src/utils/productSchema.js

@@ -0,0 +1,119 @@
+/**
+ * Maps product data to schema-friendly format for nutrition products
+ * Extracts gender and age information from Mars API data structure
+ */
+export function mapProductSchemaData(productData) {
+  let suggestedGender = null;
+  let suggestedAge = null;
+
+  // First, try to extract from Mars API structure (productContent.productContentStrictLanguage.propertyNameToValueMap)
+  const marsData = productData?.productContent?.productContentStrictLanguage?.propertyNameToValueMap;
+  if (marsData) {
+    // Extract gender from Mars data
+    if (marsData.gender && Array.isArray(marsData.gender) && marsData.gender.length > 0) {
+      suggestedGender = marsData.gender[0]; // Take first value: "Men"
+    }
+    
+    // Extract age from Mars data
+    if (marsData.googleAgeGroup && Array.isArray(marsData.googleAgeGroup) && marsData.googleAgeGroup.length > 0) {
+      suggestedAge = marsData.googleAgeGroup[0]; // Take first value: "adult"
+    }
+  }
+
+  // Fallback: try to extract from content array (your current structure)
+  if (!suggestedGender || !suggestedAge) {
+    if (productData?.content && Array.isArray(productData.content)) {
+      // Helper function to find content item by key
+      const findContentItem = (key) => {
+        return productData.content.find(item => item.key === key);
+      };
+
+      // Helper function to extract value from content item
+      const extractValue = (contentItem) => {
+        if (!contentItem?.value) return null;
+        
+        if (contentItem.value.stringValue) {
+          return contentItem.value.stringValue;
+        }
+        
+        if (contentItem.value.stringListValue && Array.isArray(contentItem.value.stringListValue)) {
+          if (contentItem.value.stringListValue.length > 0 && contentItem.value.stringListValue[0]) {
+            return contentItem.value.stringListValue[0];
+          }
+        }
+        
+        return null;
+      };
+
+      // Extract gender from content array if not found in Mars data
+      if (!suggestedGender) {
+        const genderItem = findContentItem('gender') || findContentItem('Gender') || findContentItem('targetGender');
+        if (genderItem) {
+          suggestedGender = extractValue(genderItem);
+        }
+      }
+
+      // Extract age from content array if not found in Mars data
+      if (!suggestedAge) {
+        const ageItem = findContentItem('googleAgeGroup') || findContentItem('ageGroup') || findContentItem('targetAge') || findContentItem('age');
+        if (ageItem) {
+          suggestedAge = extractValue(ageItem);
+        }
+      }
+    }
+  }
+
+  // If no gender/age found anywhere, provide reasonable defaults for nutrition products
+  if (!suggestedGender && !suggestedAge) {
+    return {
+      suggestedGender: "Unisex",
+      suggestedAge: "Adult"
+    };
+  }
+  
+  // Return the extracted values
+  const result = {};
+  if (suggestedGender) result.suggestedGender = suggestedGender;
+  if (suggestedAge) result.suggestedAge = suggestedAge;
+  
+  return result;
+}
+
+/**
+ * Enhanced version with additional nutrition-specific properties
+ */
+export function mapProductSchemaDataEnhanced(productData) {
+  const basicMapping = mapProductSchemaData(productData);
+  
+  if (!productData?.content || !Array.isArray(productData.content)) {
+    return basicMapping;
+  }
+
+  // Helper function to find and extract content values
+  const findAndExtract = (key) => {
+    const item = productData.content.find(item => item.key === key);
+    if (!item?.value) return null;
+    
+    if (item.value.stringValue) return item.value.stringValue;
+    if (item.value.stringListValue && Array.isArray(item.value.stringListValue)) {
+      return item.value.stringListValue[0];
+    }
+    return null;
+  };
+
+  return {
+    ...basicMapping,
+    brand: findAndExtract('brand'),
+    diet: findAndExtract('Diet'),
+    range: findAndExtract('range'),
+    // Add any other fields you need from the content array
+  };
+}
+
+/**
+ * Simple function to strip HTML tags from text
+ */
+export function stripHtml(html) {
+  if (!html) return '';
+  return html.replace(/<[^>]*>/g, '');
+}