@getvitops/astro 0.1.1 → 0.2.0

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@getvitops/astro",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Astro integration for the Vitops design system — favicons/PWA, web-component scripts, and CSS, via a getvitops() integration + <Head /> component.",
   "license": "MIT",
   "files": [
     "dist",
-    "Head.astro",
+    "src/components/Head.astro",
+    "src/schemas",
     "virtual.d.ts"
   ],
   "type": "module",
@@ -15,7 +16,8 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
-    "./Head.astro": "./Head.astro",
+    "./Head.astro": "./src/components/Head.astro",
+    "./schemas/*": "./src/schemas/*",
     "./package.json": "./package.json"
   },
   "publishConfig": {

package/src/schemas/Article.astro

@@ -0,0 +1,69 @@
+---
+export interface Props {
+  headline: string;
+  description?: string;
+  image?: string | string[];
+  datePublished: string;
+  dateModified?: string;
+  author: {
+    name: string;
+    url?: string;
+  } | {
+    name: string;
+    url?: string;
+  }[];
+  publisher?: {
+    name: string;
+    logo?: string;
+  };
+  mainEntityOfPage?: string;
+  articleSection?: string;
+  wordCount?: number;
+  keywords?: string[];
+}
+
+const {
+  headline,
+  description,
+  image,
+  datePublished,
+  dateModified,
+  author,
+  publisher,
+  mainEntityOfPage,
+  articleSection,
+  wordCount,
+  keywords,
+} = Astro.props;
+
+const authors = Array.isArray(author) ? author : [author];
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'Article',
+  headline,
+  ...(description && { description }),
+  ...(image && { image: Array.isArray(image) ? image : [image] }),
+  datePublished,
+  ...(dateModified && { dateModified }),
+  author: authors.map(a => ({
+    '@type': 'Person',
+    name: a.name,
+    ...(a.url && { url: a.url }),
+  })),
+  ...(publisher && {
+    publisher: {
+      '@type': 'Organization',
+      name: publisher.name,
+      ...(publisher.logo && { logo: { '@type': 'ImageObject', url: publisher.logo } }),
+    },
+  }),
+  ...(mainEntityOfPage && { mainEntityOfPage: { '@type': 'WebPage', '@id': mainEntityOfPage } }),
+  ...(articleSection && { articleSection }),
+  ...(wordCount && { wordCount }),
+  ...(keywords && { keywords: keywords.join(', ') }),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/BookActions.astro

@@ -0,0 +1,81 @@
+---
+export interface Props {
+  name: string;
+  author: string | string[];
+  url: string;
+  workExample?: {
+    isbn?: string;
+    bookEdition?: string;
+    bookFormat?: 'AudiobookFormat' | 'EBook' | 'GraphicNovel' | 'Hardcover' | 'Paperback';
+    potentialAction?: {
+      type: 'ReadAction' | 'BorrowAction' | 'BuyAction';
+      target: string;
+      expectsAcceptanceOf?: {
+        availabilityStarts?: string;
+        availabilityEnds?: string;
+        category?: 'free' | 'subscription' | 'purchase' | 'rental';
+      };
+    };
+  }[];
+  sameAs?: string[];
+  image?: string;
+  description?: string;
+}
+
+const {
+  name,
+  author,
+  url,
+  workExample,
+  sameAs,
+  image,
+  description,
+} = Astro.props;
+
+const authors = Array.isArray(author) ? author : [author];
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'Book',
+  name,
+  author: authors.map(a => ({
+    '@type': 'Person',
+    name: a,
+  })),
+  url,
+  ...(sameAs && { sameAs }),
+  ...(image && { image }),
+  ...(description && { description }),
+  ...(workExample && {
+    workExample: workExample.map(we => ({
+      '@type': 'Book',
+      ...(we.isbn && { isbn: we.isbn }),
+      ...(we.bookEdition && { bookEdition: we.bookEdition }),
+      ...(we.bookFormat && { bookFormat: `https://schema.org/${we.bookFormat}` }),
+      ...(we.potentialAction && {
+        potentialAction: {
+          '@type': we.potentialAction.type,
+          target: {
+            '@type': 'EntryPoint',
+            urlTemplate: we.potentialAction.target,
+            actionPlatform: [
+              'https://schema.org/DesktopWebPlatform',
+              'https://schema.org/AndroidPlatform',
+              'https://schema.org/IOSPlatform',
+            ],
+          },
+          ...(we.potentialAction.expectsAcceptanceOf && {
+            expectsAcceptanceOf: {
+              '@type': 'Offer',
+              ...we.potentialAction.expectsAcceptanceOf,
+            },
+          }),
+        },
+      }),
+    })),
+  }),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/Breadcrumb.astro

@@ -0,0 +1,26 @@
+---
+export interface BreadcrumbItem {
+  name: string;
+  url: string;
+}
+
+export interface Props {
+  items: BreadcrumbItem[];
+}
+
+const { items } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'BreadcrumbList',
+  itemListElement: items.map((item, index) => ({
+    '@type': 'ListItem',
+    position: index + 1,
+    name: item.name,
+    item: item.url,
+  })),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/Carousel.astro

@@ -0,0 +1,34 @@
+---
+export interface CarouselItem {
+  type: 'Article' | 'Recipe' | 'Movie' | 'Course' | 'Restaurant' | 'Product';
+  name: string;
+  url: string;
+  image?: string;
+  description?: string;
+}
+
+export interface Props {
+  items: CarouselItem[];
+}
+
+const { items } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'ItemList',
+  itemListElement: items.map((item, index) => ({
+    '@type': 'ListItem',
+    position: index + 1,
+    item: {
+      '@type': item.type,
+      name: item.name,
+      url: item.url,
+      ...(item.image && { image: item.image }),
+      ...(item.description && { description: item.description }),
+    },
+  })),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/CourseList.astro

@@ -0,0 +1,122 @@
+---
+export interface CourseInstance {
+  courseMode: 'online' | 'onsite' | 'blended';
+  startDate?: string;
+  endDate?: string;
+  location?: {
+    name: string;
+    address?: string;
+  };
+  instructor?: {
+    name: string;
+    url?: string;
+  };
+  courseSchedule?: {
+    repeatFrequency: string;
+    repeatCount?: number;
+  };
+}
+
+export interface Course {
+  name: string;
+  description: string;
+  provider: {
+    name: string;
+    url?: string;
+  };
+  url?: string;
+  image?: string;
+  offers?: {
+    price: number | string;
+    priceCurrency: string;
+    availability?: 'InStock' | 'SoldOut' | 'PreOrder';
+    validFrom?: string;
+  };
+  hasCourseInstance?: CourseInstance[];
+  educationalLevel?: string;
+  about?: string[];
+  teaches?: string[];
+  financialAidEligible?: boolean;
+  inLanguage?: string;
+  duration?: string;
+}
+
+export interface Props {
+  courses: Course[];
+}
+
+const { courses } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'ItemList',
+  itemListElement: courses.map((course, index) => ({
+    '@type': 'ListItem',
+    position: index + 1,
+    item: {
+      '@type': 'Course',
+      name: course.name,
+      description: course.description,
+      provider: {
+        '@type': 'Organization',
+        name: course.provider.name,
+        ...(course.provider.url && { sameAs: course.provider.url }),
+      },
+      ...(course.url && { url: course.url }),
+      ...(course.image && { image: course.image }),
+      ...(course.offers && {
+        offers: {
+          '@type': 'Offer',
+          price: course.offers.price,
+          priceCurrency: course.offers.priceCurrency,
+          ...(course.offers.availability && { availability: `https://schema.org/${course.offers.availability}` }),
+          ...(course.offers.validFrom && { validFrom: course.offers.validFrom }),
+        },
+      }),
+      ...(course.hasCourseInstance && {
+        hasCourseInstance: course.hasCourseInstance.map(instance => ({
+          '@type': 'CourseInstance',
+          courseMode: instance.courseMode,
+          ...(instance.startDate && { startDate: instance.startDate }),
+          ...(instance.endDate && { endDate: instance.endDate }),
+          ...(instance.location && {
+            location: {
+              '@type': 'Place',
+              name: instance.location.name,
+              ...(instance.location.address && {
+                address: {
+                  '@type': 'PostalAddress',
+                  streetAddress: instance.location.address,
+                },
+              }),
+            },
+          }),
+          ...(instance.instructor && {
+            instructor: {
+              '@type': 'Person',
+              name: instance.instructor.name,
+              ...(instance.instructor.url && { url: instance.instructor.url }),
+            },
+          }),
+          ...(instance.courseSchedule && {
+            courseSchedule: {
+              '@type': 'Schedule',
+              repeatFrequency: instance.courseSchedule.repeatFrequency,
+              ...(instance.courseSchedule.repeatCount && { repeatCount: instance.courseSchedule.repeatCount }),
+            },
+          }),
+        })),
+      }),
+      ...(course.educationalLevel && { educationalLevel: course.educationalLevel }),
+      ...(course.about && { about: course.about }),
+      ...(course.teaches && { teaches: course.teaches }),
+      ...(course.financialAidEligible && { financialAidEligible: 'true' }),
+      ...(course.inLanguage && { inLanguage: course.inLanguage }),
+      ...(course.duration && { timeRequired: course.duration }),
+    },
+  })),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/Dataset.astro

@@ -0,0 +1,127 @@
+---
+export interface Props {
+  name: string;
+  description: string;
+  url?: string;
+  sameAs?: string;
+  identifier?: string | string[];
+  keywords?: string[];
+  license?: string;
+  isAccessibleForFree?: boolean;
+  creator?: {
+    type: 'Person' | 'Organization';
+    name: string;
+    url?: string;
+  };
+  funder?: {
+    type: 'Person' | 'Organization';
+    name: string;
+  };
+  includedInDataCatalog?: {
+    name: string;
+    url?: string;
+  };
+  distribution?: {
+    contentUrl: string;
+    encodingFormat: string;
+    contentSize?: string;
+  }[];
+  temporalCoverage?: string;
+  spatialCoverage?: {
+    type: 'Place';
+    geo?: {
+      latitude: number;
+      longitude: number;
+      box?: string;
+    };
+  };
+  variableMeasured?: string | string[];
+  measurementTechnique?: string;
+  datePublished?: string;
+  dateModified?: string;
+}
+
+const {
+  name,
+  description,
+  url,
+  sameAs,
+  identifier,
+  keywords,
+  license,
+  isAccessibleForFree,
+  creator,
+  funder,
+  includedInDataCatalog,
+  distribution,
+  temporalCoverage,
+  spatialCoverage,
+  variableMeasured,
+  measurementTechnique,
+  datePublished,
+  dateModified,
+} = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'Dataset',
+  name,
+  description,
+  ...(url && { url }),
+  ...(sameAs && { sameAs }),
+  ...(identifier && { identifier }),
+  ...(keywords && { keywords }),
+  ...(license && { license }),
+  ...(isAccessibleForFree !== undefined && { isAccessibleForFree }),
+  ...(creator && {
+    creator: {
+      '@type': creator.type,
+      name: creator.name,
+      ...(creator.url && { url: creator.url }),
+    },
+  }),
+  ...(funder && {
+    funder: {
+      '@type': funder.type,
+      name: funder.name,
+    },
+  }),
+  ...(includedInDataCatalog && {
+    includedInDataCatalog: {
+      '@type': 'DataCatalog',
+      name: includedInDataCatalog.name,
+      ...(includedInDataCatalog.url && { url: includedInDataCatalog.url }),
+    },
+  }),
+  ...(distribution && {
+    distribution: distribution.map(d => ({
+      '@type': 'DataDownload',
+      contentUrl: d.contentUrl,
+      encodingFormat: d.encodingFormat,
+      ...(d.contentSize && { contentSize: d.contentSize }),
+    })),
+  }),
+  ...(temporalCoverage && { temporalCoverage }),
+  ...(spatialCoverage && {
+    spatialCoverage: {
+      '@type': 'Place',
+      ...(spatialCoverage.geo && {
+        geo: spatialCoverage.geo.box
+          ? { '@type': 'GeoShape', box: spatialCoverage.geo.box }
+          : {
+              '@type': 'GeoCoordinates',
+              latitude: spatialCoverage.geo.latitude,
+              longitude: spatialCoverage.geo.longitude,
+            },
+      }),
+    },
+  }),
+  ...(variableMeasured && { variableMeasured }),
+  ...(measurementTechnique && { measurementTechnique }),
+  ...(datePublished && { datePublished }),
+  ...(dateModified && { dateModified }),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/DiscussionForum.astro

@@ -0,0 +1,82 @@
+---
+export interface ForumPost {
+  headline: string;
+  text: string;
+  url: string;
+  datePublished: string;
+  author: {
+    name: string;
+    url?: string;
+  };
+  interactionStatistic?: {
+    type: 'ReplyAction' | 'LikeAction' | 'ViewAction';
+    count: number;
+  }[];
+  comment?: {
+    text: string;
+    datePublished: string;
+    author: {
+      name: string;
+      url?: string;
+    };
+  }[];
+}
+
+export interface Props {
+  name: string;
+  url: string;
+  description?: string;
+  mainEntity?: ForumPost[];
+}
+
+const { name, url, description, mainEntity } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'DiscussionForumPosting',
+  ...(mainEntity && mainEntity.length > 0
+    ? {
+        mainEntity: mainEntity.map(post => ({
+          '@type': 'DiscussionForumPosting',
+          headline: post.headline,
+          text: post.text,
+          url: post.url,
+          datePublished: post.datePublished,
+          author: {
+            '@type': 'Person',
+            name: post.author.name,
+            ...(post.author.url && { url: post.author.url }),
+          },
+          ...(post.interactionStatistic && {
+            interactionStatistic: post.interactionStatistic.map(stat => ({
+              '@type': 'InteractionCounter',
+              interactionType: { '@type': stat.type },
+              userInteractionCount: stat.count,
+            })),
+          }),
+          ...(post.comment && {
+            comment: post.comment.map(c => ({
+              '@type': 'Comment',
+              text: c.text,
+              datePublished: c.datePublished,
+              author: {
+                '@type': 'Person',
+                name: c.author.name,
+                ...(c.author.url && { url: c.author.url }),
+              },
+            })),
+          }),
+        })),
+      }
+    : {}),
+  isPartOf: {
+    '@type': 'WebPage',
+    '@id': url,
+    name,
+    ...(description && { description }),
+  },
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/EducationQA.astro

@@ -0,0 +1,63 @@
+---
+export interface Props {
+  mainEntity: {
+    question: string;
+    answer: {
+      text: string;
+      author?: {
+        name: string;
+        type?: 'Person' | 'Organization';
+      };
+      dateCreated?: string;
+      upvoteCount?: number;
+      url?: string;
+    };
+    eduQuestionType?: 'Practice' | 'Test' | 'Homework' | 'Quiz' | 'Exam';
+    learningResourceType?: string;
+    assesses?: string;
+    educationalLevel?: string;
+  }[];
+  about?: {
+    name: string;
+    url?: string;
+  };
+}
+
+const { mainEntity, about } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'Quiz',
+  ...(about && {
+    about: {
+      '@type': 'Thing',
+      name: about.name,
+      ...(about.url && { url: about.url }),
+    },
+  }),
+  hasPart: mainEntity.map(qa => ({
+    '@type': 'Question',
+    eduQuestionType: qa.eduQuestionType || 'Practice',
+    ...(qa.learningResourceType && { learningResourceType: qa.learningResourceType }),
+    ...(qa.assesses && { assesses: qa.assesses }),
+    ...(qa.educationalLevel && { educationalLevel: qa.educationalLevel }),
+    text: qa.question,
+    acceptedAnswer: {
+      '@type': 'Answer',
+      text: qa.answer.text,
+      ...(qa.answer.author && {
+        author: {
+          '@type': qa.answer.author.type || 'Person',
+          name: qa.answer.author.name,
+        },
+      }),
+      ...(qa.answer.dateCreated && { dateCreated: qa.answer.dateCreated }),
+      ...(qa.answer.upvoteCount !== undefined && { upvoteCount: qa.answer.upvoteCount }),
+      ...(qa.answer.url && { url: qa.answer.url }),
+    },
+  })),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />

package/src/schemas/EmployerAggregateRating.astro

@@ -0,0 +1,54 @@
+---
+export interface Props {
+  name: string;
+  url?: string;
+  logo?: string;
+  sameAs?: string[];
+  aggregateRating: {
+    ratingValue: number;
+    bestRating?: number;
+    worstRating?: number;
+    ratingCount?: number;
+    reviewCount?: number;
+  };
+  address?: {
+    streetAddress?: string;
+    addressLocality?: string;
+    addressRegion?: string;
+    postalCode?: string;
+    addressCountry?: string;
+  };
+}
+
+const { name, url, logo, sameAs, aggregateRating, address } = Astro.props;
+
+const jsonLd = {
+  '@context': 'https://schema.org',
+  '@type': 'EmployerAggregateRating',
+  itemReviewed: {
+    '@type': 'Organization',
+    name,
+    ...(url && { url }),
+    ...(logo && { logo }),
+    ...(sameAs && { sameAs }),
+    ...(address && {
+      address: {
+        '@type': 'PostalAddress',
+        ...(address.streetAddress && { streetAddress: address.streetAddress }),
+        ...(address.addressLocality && { addressLocality: address.addressLocality }),
+        ...(address.addressRegion && { addressRegion: address.addressRegion }),
+        ...(address.postalCode && { postalCode: address.postalCode }),
+        ...(address.addressCountry && { addressCountry: address.addressCountry }),
+      },
+    }),
+  },
+  ratingValue: aggregateRating.ratingValue,
+  bestRating: aggregateRating.bestRating ?? 5,
+  worstRating: aggregateRating.worstRating ?? 1,
+  ...(aggregateRating.ratingCount && { ratingCount: aggregateRating.ratingCount }),
+  ...(aggregateRating.reviewCount && { reviewCount: aggregateRating.reviewCount }),
+};
+---
+
+<script is:inline type="application/ld+json" set:html={JSON.stringify(jsonLd)} />
+<slot />