@sarimarcus/content-sites-core 0.13.0 → 0.15.0

package/src/schema/types.ts

@@ -0,0 +1,87 @@
+/** A JSON-LD node as assembled. `undefined` values are dropped when the graph is serialised. */
+export type JsonLdNode = Record<string, any>;
+
+/** One `{ type, data }` entry a page hands to its StructuredData component. */
+export interface SchemaEntry<T extends string = string> {
+  type: T;
+  data: Record<string, any>;
+}
+
+export interface OpeningHoursSpecification {
+  '@type': 'OpeningHoursSpecification';
+  dayOfWeek: string | string[];
+  opens: string;
+  closes: string;
+}
+
+export interface IdRef {
+  '@id': string;
+}
+
+/** An author record as the site stores it; only these fields reach JSON-LD. */
+export interface SchemaAuthorProfile {
+  name: string;
+  slug?: string;
+  photo?: string;
+  socialLinks?: string[];
+}
+
+export interface ResolvedAuthor {
+  id: string;
+  name: string;
+  url: string;
+  image?: string;
+  sameAs?: string[];
+}
+
+/** Path segment per entity kind, e.g. `{ hotel: 'lodges' }`. A kind not listed uses its own name. */
+export type RouteMap = Partial<Record<string, string>>;
+
+export interface SchemaContextInput {
+  /** Site origin, with or without a trailing slash. */
+  siteUrl: string;
+  /** Base path without a trailing slash (`''` at the root). */
+  basePath: string;
+  /** The page's own pathname (`Astro.url.pathname`). */
+  pagePath: string;
+  /** Whether a file exists under the site's `public/` (path with a leading slash). Defaults to "no". */
+  fileExists?: (publicPath: string) => boolean;
+  /** An image path containing this marker is already an OG image. */
+  ogImageMarker?: string;
+  /** Author profile by display name. */
+  findAuthor?: (name: string) => SchemaAuthorProfile | undefined;
+  /** Markdown → plain text, for JSON-LD string values. */
+  plainText?: (markdown: string) => string;
+  /** `publisher` for a content item, given its author. Defaults to the Organization. */
+  publisher?: (authorName: string | undefined, ctx: SchemaContext) => IdRef;
+  /** Route segments per entity kind. */
+  routes?: RouteMap;
+  /** Clock for the future-date clamp and `defaultToNow`. */
+  now?: () => Date;
+}
+
+export interface SchemaContext {
+  siteUrl: string;
+  basePath: string;
+  siteBaseUrl: string;
+  pageUrl: string;
+  orgId: string;
+  websiteId: string;
+  /** `${siteUrl}${basePath}${path}` for a root-relative path. */
+  abs(path: string): string;
+  /** A root-relative path made absolute; an `http…` value passes through. */
+  absOrHttp(path: string): string;
+  /** Item URL for an entity kind: `${siteUrl}${basePath}/${segment}/${slug}`. */
+  route(kind: string, slug: string): string;
+  fileExists(publicPath: string): boolean;
+  resolveImageUrl(imagePath: string | undefined, slug?: string): string | undefined;
+  resolveAuthor(authorName: string | undefined): ResolvedAuthor | null;
+  formatDate(dateStr: string | undefined, defaultToNow?: boolean): string | undefined;
+  plainText(markdown: string): string;
+  publisherFor(authorName: string | undefined): IdRef;
+}
+
+/** Builds the node(s) for one schema entry; `null` emits nothing. */
+export type SchemaBuilder = (data: Record<string, any>, ctx: SchemaContext) => JsonLdNode | JsonLdNode[] | null;
+
+export type SchemaBuilders = Record<string, SchemaBuilder>;

package/src/schema/values.ts

@@ -0,0 +1,102 @@
+import type { JsonLdNode } from './types.ts';
+
+/** First integer in a price string; any "free" reads as 0; null when there is no number. */
+export function parsePriceFromString(priceStr: string | undefined): number | null {
+  if (!priceStr) return null;
+  if (priceStr.toLowerCase().includes('free')) return 0;
+  const match = priceStr.match(/(\d+)/);
+  return match ? parseFloat(match[1]) : null;
+}
+
+/** Street and number only: drops postal code, city and country, and a second part that is a district or postcode. */
+export function cleanStreetAddress(fullAddress: string | undefined): string {
+  if (!fullAddress) return '';
+  const parts = fullAddress.split(',').map((p) => p.trim());
+  const streetName = parts[0];
+  if (parts.length < 2) return streetName;
+  const cleanedNumber = parts[1].replace(/º\s*/g, '').trim();
+  const isNeighbourhoodOrPostal =
+    /^\d{5}/.test(cleanedNumber) || /^[A-ZÁÉÍÓÚÜÑ][a-záéíóúüñ]/.test(cleanedNumber);
+  return isNeighbourhoodOrPostal || !cleanedNumber ? streetName : `${streetName}, ${cleanedNumber}`;
+}
+
+/** A €-symbol range (`€`…`€€€€`) from a price string, inferred from `priceFrom` when given. */
+export function normalizePriceRange(priceStr: string | undefined, priceFrom?: number): string {
+  if (!priceStr) return '€€';
+  if (/^€+$/.test(priceStr)) return priceStr;
+  const price = priceFrom || parsePriceFromString(priceStr) || 10;
+  if (price < 10) return '€';
+  if (price < 20) return '€€';
+  if (price < 40) return '€€€';
+  return '€€€€';
+}
+
+/** A hotel range as `€120-€200` (from `120-200€`), else `€€€`. */
+export function normalizeHotelPriceRange(priceStr: string | undefined): string {
+  if (!priceStr) return '€€€';
+  if (/^€\d+-€\d+$/.test(priceStr)) return priceStr;
+  const match = priceStr.match(/(\d+)-(\d+)€?/);
+  if (match) return `€${match[1]}-€${match[2]}`;
+  return '€€€';
+}
+
+/** `postalCode`, else the first 5-digit run in `address`. */
+export function postalCodeOf(data: { postalCode?: string; address?: string }): string | undefined {
+  return data.postalCode || data.address?.match(/(\d{5})/)?.[1];
+}
+
+/** How an entity's PostalAddress is filled: fixed city values or per-item fields. */
+export interface AddressPolicy {
+  locality(data: Record<string, any>): string | undefined;
+  region(data: Record<string, any>): string | undefined;
+  country(data: Record<string, any>): string | undefined;
+  /** Postal code used when the item has none. */
+  postalFallback?: string;
+  /** Drop an empty street (`""`) instead of emitting it. */
+  omitEmptyStreet?: boolean;
+}
+
+/** Address read from each item's own `city`, `region` and `country`; empty values are dropped. */
+export function dataAddressPolicy(): AddressPolicy {
+  return {
+    locality: (d) => d.city || undefined,
+    region: (d) => d.region || undefined,
+    country: (d) => d.country || undefined,
+    omitEmptyStreet: true,
+  };
+}
+
+export interface PostalAddressParts {
+  /** Raw address to clean into `streetAddress`. Absent: no street key. */
+  street?: string;
+  /** Postal code before the policy fallback. Absent: no postal key. */
+  postalCode?: string;
+}
+
+/** A PostalAddress in the fixed key order: street, locality, region, postal code, country. */
+export function postalAddress(policy: AddressPolicy, data: Record<string, any>, parts: PostalAddressParts = {}): JsonLdNode {
+  const node: JsonLdNode = { '@type': 'PostalAddress' };
+  if ('street' in parts) {
+    const street = cleanStreetAddress(parts.street);
+    node.streetAddress = policy.omitEmptyStreet ? street || undefined : street;
+  }
+  node.addressLocality = policy.locality(data);
+  node.addressRegion = policy.region(data);
+  if ('postalCode' in parts) node.postalCode = parts.postalCode || policy.postalFallback;
+  node.addressCountry = policy.country(data);
+  return node;
+}
+
+export function geoCoordinates(coordinates: { lat: number; lng: number } | undefined): JsonLdNode | undefined {
+  return coordinates ? { '@type': 'GeoCoordinates', latitude: coordinates.lat, longitude: coordinates.lng } : undefined;
+}
+
+export function aggregateRating(data: { rating?: number; ratingCount?: number }): JsonLdNode | undefined {
+  return data.rating ? {
+    '@type': 'AggregateRating',
+    ratingValue: data.rating,
+    bestRating: 5,
+    worstRating: 1,
+    reviewCount: data.ratingCount ?? 1,
+  } : undefined;
+}