@thg-altitude/schemaorg 1.0.32 → 1.0.34

package/src/components/Product.astro

@@ -1,70 +1,382 @@
 ---
-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 non-standard properties as additionalProperty
+        const additionalProperties = [];
+        
+        if (variant.amount) {
+          additionalProperties.push({
+            "@type": "PropertyValue",
+            "name": "amount",
+            "value": variant.amount
+          });
+        }
+        
+        // Handle flavour as additionalProperty since it doesn't exist in schema.org
+        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": "flavour",
+            "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 flavour, we use additionalProperty
+    if (Astro.props.variants.some(v => v && v.amount)) variesBy.push("https://schema.org/additionalProperty");
+    
+    // Check for flavor with multiple possible property names - treat as additionalProperty
+    if (Astro.props.variants.some(v => v && (v.flavor || v.flavour || v.taste))) {
+      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
+    });
+  }
+  
+  // Add flavour as additionalProperty for ProductGroup level
+  if (Array.isArray(Astro.props.variants)) {
+    const flavourValues = Astro.props.variants.map(v => {
+      if (v && typeof v === 'object') {
+        return v.flavor || v.flavour || v.taste;
+      }
+      return null;
+    }).filter(Boolean);
+    
+    if (flavourValues.length > 0) {
+      // If multiple unique flavours, list them all; if single flavour, just that one
+      const uniqueFlavours = [...new Set(flavourValues)];
+      additionalProperties.push({
+        "@type": "PropertyValue",
+        "name": "flavour",
+        "value": uniqueFlavours.length === 1 ? uniqueFlavours[0] : uniqueFlavours.join(', ')
+      });
+    }
+  }
+  
+  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
+    });
+  }
+  
+  // Add flavour as additionalProperty for single product
+  if (Array.isArray(Astro.props.variants)) {
+    const flavourValues = Astro.props.variants.map(v => {
+      if (v && typeof v === 'object') {
+        return v.flavor || v.flavour || v.taste;
+      }
+      return null;
+    }).filter(Boolean);
+    
+    if (flavourValues.length > 0) {
+      // If multiple unique flavours, list them all; if single flavour, just that one
+      const uniqueFlavours = [...new Set(flavourValues)];
+      additionalProperties.push({
+        "@type": "PropertyValue",
+        "name": "flavour",
+        "value": uniqueFlavours.length === 1 ? uniqueFlavours[0] : uniqueFlavours.join(', ')
+      });
+    }
+  }
+  
+  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)}
+    />
+  )
+}