@thg-altitude/schemaorg 1.0.23 → 1.0.25

package/index.js

@@ -1,4 +1,5 @@
 import Product from './src/components/Product.astro'
+import EnhancedProduct from './src/components/EnhancedProduct.astro'
 import Breadcrumb from './src/components/Breadcrumb.astro'
 import CollectionPage from './src/components/CollectionPage.astro'
 import Organization from './src/components/Organization.astro'
@@ -7,6 +8,7 @@ import WebSite from './src/components/WebSite.astro'
 
 export { 
     Product,
+    EnhancedProduct,
     Breadcrumb,
     CollectionPage,
     Organization,

package/package.json

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

package/src/components/EnhancedProduct.astro

@@ -0,0 +1,286 @@
+---
+const {
+  image,
+  sku,
+  name,
+  gtin13,
+  description,
+  variants,
+  currency,
+  brand,
+  urlPath,
+  reviews,
+  reviewsCount,
+  reviewsAverage,
+  breadcrumbs,
+  country,
+  faqs,
+  keywords,
+  saleEventTitle,
+  saleEventDescription,
+  saleEventStartDate,
+  saleEventEndDate,
+  streetAddress,
+  addressLocality,
+  postalCode,
+} = Astro.props;
+
+let url;
+let schema = null;
+let schemaError = false;
+let offersArray = [];
+let graphArray = [];
+let imageUrl;
+let pageUrl;
+
+try {
+  url = import.meta.env.DEV
+    ? Astro.url.origin
+    : `${Astro.request.headers.get("X-forwarded-Proto")}://${Astro.request.headers.get("X-forwarded-Host")?.split(", ")[0]}`;
+  imageUrl = image
+    ? `${import.meta.env.IMAGE_PROXY_URL}?url=${image}&format=webp&width=1500&height=1500&fit=cover`
+    : null;
+  pageUrl = urlPath ? `${url}${urlPath}` : url;
+
+  if (!name || !sku || !image) {
+    throw new Error("Invalid data. Unable to produce Product Schema");
+  }
+
+  generateProductSchema();
+  generateSaleEventSchema();
+  generateBreadcrumbListSchema();
+  generateFaqPageSchema();
+
+  if (graphArray.length > 0) {
+    schema = {
+      "@context": "https://schema.org/",
+      "@graph": graphArray,
+    };
+  }
+} catch (e) {
+  console.error("Invalid data. Unable to produce Product Schema");
+  schemaError = true;
+}
+
+function generateProductSchema() {
+  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
+            ? [
+                {
+                  "@type": "UnitPriceSpecification",
+                  priceCurrency: currency,
+                  price: variant.price.rrp.amount,
+                  valueAddedTaxIncluded: true,
+                  priceType: "https://schema.org/ListPrice",
+                },
+              ]
+            : []),
+        ],
+      }));
+  }
+
+  const category =
+    breadcrumbs?.length > 2
+      ? breadcrumbs?.[breadcrumbs.length - 2]?.displayName
+      : null;
+
+  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,
+          },
+        }),
+      ...(reviewsArray && reviewsArray.length > 0 && { review: reviewsArray }),
+      ...(category && { category }),
+      ...(keywords && { keywords }),
+      ...(offersArray.length > 0 && { offers: offersArray }),
+    };
+
+    graphArray.push(productSchema);
+  }
+}
+
+function generateSaleEventSchema() {
+  if (saleEventTitle && saleEventDescription && saleEventStartDate && brand) {
+    let saleEventSchema = {
+      "@type": "SaleEvent",
+      name: saleEventTitle,
+      url: pageUrl,
+      description: saleEventDescription,
+      ...(imageUrl && { image: imageUrl }),
+      eventStatus: "https://schema.org/EventScheduled",
+      eventAttendanceMode: "https://schema.org/OnlineEventAttendanceMode",
+      organizer: {
+        "@type": "Organization",
+        name: brand,
+        url: url,
+      },
+      location: {
+        "@type": "Place",
+        name: brand,
+        url: url,
+      },
+      startDate: saleEventStartDate,
+      ...(saleEventEndDate && { endDate: saleEventEndDate }),
+    };
+
+    if (streetAddress && addressLocality && postalCode && country) {
+      saleEventSchema.location.address = {
+        "@type": "PostalAddress",
+        streetAddress: streetAddress,
+        addressLocality: addressLocality,
+        postalCode: postalCode,
+        addressCountry: country,
+      };
+    }
+
+    offersArray.length > 0 && (saleEventSchema.offers = offersArray);
+
+    graphArray.push(saleEventSchema);
+  }
+}
+
+function generateBreadcrumbListSchema() {
+  if (breadcrumbs && breadcrumbs.length > 0) {
+    let breadcrumbArray = breadcrumbs
+      .filter((breadcrumb) => breadcrumb?.displayName && breadcrumb?.pagePath)
+      .map((breadcrumb, index) => ({
+        "@type": "ListItem",
+        position: index + 1,
+        name: breadcrumb.displayName,
+        item: `${url}${breadcrumb.pagePath}`,
+      }));
+
+    if (breadcrumbArray.length > 0) {
+      const breadcrumbListSchema = {
+        "@type": "BreadcrumbList",
+        itemListElement: breadcrumbArray,
+      };
+
+      graphArray.push(breadcrumbListSchema);
+    }
+  }
+}
+
+function generateFaqPageSchema() {
+  if (faqs && faqs.length > 0) {
+    let faqArray = faqs
+      .filter((faq) => faq?.title && faq?.body)
+      .map((faq) => ({
+        "@type": "Question",
+        name: faq.title,
+        acceptedAnswer: {
+          "@type": "Answer",
+          text: faq.body,
+        },
+      }));
+
+    if (faqArray.length > 0) {
+      const faqPageSchema = {
+        "@type": "FAQPage",
+        mainEntity: faqArray,
+      };
+      graphArray.push(faqPageSchema);
+    }
+  }
+}
+
+function generateReviewsSchema() {
+  if (reviews && reviews.length > 0 && name) {
+    let reviewsArray = reviews
+      .filter(
+        (review) => review?.elements && review?.authorName && review?.posted
+      )
+      .map((review) => {
+        const content = review?.elements?.find(
+          (el) => el.key === "content"
+        )?.value;
+        const score = review?.elements?.find((el) => el.key === "score")?.score;
+
+        if (!content || !score) return;
+
+        return {
+          "@type": "Review",
+          description: content,
+          datePublished: review.posted,
+          itemReviewed: {
+            "@id": pageUrl,
+          },
+          reviewRating: {
+            "@type": "Rating",
+            worstRating: 1,
+            bestRating: 5,
+            ratingValue: score,
+          },
+          author: {
+            "@type": "Person",
+            name: review.authorName,
+          },
+        };
+      });
+
+    if (reviewsArray && reviewsArray.length > 0) {
+      return reviewsArray;
+    } else {
+      return null;
+    }
+  }
+}
+---
+
+{
+  schema && !schemaError && (
+    <script type="application/ld+json" set:html={JSON.stringify(schema)} />
+  )
+}

package/src/components/Product.astro

@@ -21,24 +21,30 @@ let reviewsArray = []
 Astro.props.reviews?.forEach((review)=>{
   reviewsArray.push({
     "@type": "Review",
-          "reviewRating": {
-            "@type": "Rating",
-            "ratingValue": review?.elements?.[0]?.score,
-            "bestRating": "5"
-          },
-          "author": {
-            "@type": "Person",
-            "name": review?.authorName
-          },
-          "datePublished": review?.posted,
-          "reviewBody":  review?.elements?.[1]?.value
-  })
-})
+    itemReviewed: {
+      "@type": "Product",
+      name: Astro.props.name,
+    },
+    reviewRating: {
+      "@type": "Rating",
+      ratingValue: review?.elements?.[0]?.score,
+      bestRating: "5",
+    },
+    author: {
+      "@type": "Person",
+      name: review?.authorName,
+    },
+    datePublished: review?.posted,
+    reviewBody: review?.elements?.[1]?.value,
+  });
+});
 
 let aggregateRating = Astro.props.reviewsCount > 0 ? {
 	"@type": "AggregateRating",
 	"ratingValue": Astro.props.reviewsAverage,
-	"reviewCount": Astro.props.reviewsCount
+	"reviewCount": Astro.props.reviewsCount,
+  bestRating: 5,
+  worstRating: 1,
 } : undefined
 
 let schema = {