sitero 0.0.1

package/dist/src/web/client/applications/structured-data/build/build-content.js

@@ -0,0 +1,72 @@
+import 'mime-types';
+import { findTranslation } from '../../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../../shared/utils/join-url.js';
+import { toIsoTime } from '../../../../../shared/utils/to-iso-time.js';
+
+function createBuildContent({ storageUrl }) {
+  return function buildContent(pageIdentity, params) {
+    const { locale, pageUrl, siteUrl, publisherId } = pageIdentity;
+    const { type, post, authorId } = params;
+    const { translations, seoMetadatas, author, coverImage } = post || {};
+    const postT = findTranslation(translations, locale);
+    const seoMetadata = findTranslation(seoMetadatas, locale);
+    const authorT = findTranslation(author?.translations, locale);
+    const coverImageT = findTranslation(coverImage?.translations, locale);
+    const title = seoMetadata?.title ?? postT?.title;
+    const description = seoMetadata?.description ?? postT?.description;
+    const publishedAt = seoMetadata?.ogArticlePublishedTime ? toIsoTime(seoMetadata.ogArticlePublishedTime) : void 0;
+    const modifiedAt = seoMetadata?.ogArticleModifiedTime ? toIsoTime(seoMetadata.ogArticleModifiedTime) : void 0;
+    const entityId = `${pageUrl}#${type.toLowerCase()}`;
+    return {
+      "@type": type,
+      "@id": entityId,
+      url: pageUrl,
+      // --------------------------------------------------
+      // identity
+      // --------------------------------------------------
+      ...type === "Article" && title && { headline: title },
+      ...type === "CreativeWork" && title && { name: title },
+      ...description && { description },
+      ...locale && { inLanguage: locale },
+      // --------------------------------------------------
+      // relation
+      // --------------------------------------------------
+      publisher: {
+        "@id": publisherId
+      },
+      // --------------------------------------------------
+      // image
+      // --------------------------------------------------
+      ...coverImage && {
+        image: {
+          "@type": "ImageObject",
+          "@id": `image:${coverImage.id}`,
+          url: joinUrl(storageUrl, coverImage.key),
+          ...coverImageT.alt && { caption: coverImageT.alt },
+          ...coverImage.width && { width: coverImage.width },
+          ...coverImage.height && { height: coverImage.height }
+        }
+      },
+      // --------------------------------------------------
+      // author
+      // --------------------------------------------------
+      ...authorId && { author: { "@id": authorId } },
+      ...!authorId && authorT?.authorName && post?.author?.id && {
+        author: {
+          "@type": "Person",
+          "@id": `${siteUrl}#author-${author?.id}`,
+          name: authorT.authorName
+        }
+      },
+      // --------------------------------------------------
+      // date
+      // --------------------------------------------------
+      ...publishedAt && { datePublished: publishedAt },
+      ...modifiedAt && { dateModified: modifiedAt }
+    };
+  };
+}
+
+export { createBuildContent };

package/dist/src/web/client/applications/structured-data/build/build-publisher.js

@@ -0,0 +1,81 @@
+function createBuildPublisher({
+  siteConfig
+}) {
+  return function buildPublisher(pageIdentity) {
+    const { locale, publisherId } = pageIdentity;
+    const { publisher } = siteConfig;
+    if (publisher.type === "person") {
+      const { name: publisherName2, sameAs: sameAs2, avatar } = publisher;
+      const name2 = publisherName2[locale];
+      return {
+        "@type": "Person",
+        "@id": publisherId,
+        url: siteConfig.site.url,
+        ...name2 && { name: name2 },
+        ...sameAs2 && { sameAs: sameAs2 },
+        ...avatar && {
+          image: {
+            "@type": "ImageObject",
+            "@id": `${publisherId}/avatar`,
+            url: avatar.url,
+            ...avatar.alt && { caption: avatar.alt },
+            ...avatar.width && { width: avatar.width },
+            ...avatar.height && { height: avatar.height }
+          }
+        }
+      };
+    }
+    const {
+      url,
+      name: publisherName,
+      description: publisherDescription,
+      sameAs,
+      email,
+      telephone,
+      address,
+      logo
+    } = publisher;
+    const name = publisherName[locale];
+    const description = publisherDescription?.[locale];
+    return {
+      "@type": "Organization",
+      "@id": publisherId,
+      url: url ?? siteConfig.site.url,
+      ...name && { name },
+      ...description && { description },
+      ...sameAs && { sameAs },
+      ...email && { email },
+      ...telephone && { telephone },
+      ...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
+          }
+        }
+      },
+      ...logo && {
+        logo: {
+          "@type": "ImageObject",
+          "@id": `${publisherId}/logo`,
+          url: logo.url,
+          ...logo.alt && { caption: logo.alt },
+          ...logo.width && { width: logo.width },
+          ...logo.height && { height: logo.height }
+        }
+      }
+    };
+  };
+}
+
+export { createBuildPublisher };

package/dist/src/web/client/applications/structured-data/build/build-topic-item-list.js

@@ -0,0 +1,44 @@
+function buildTopicItemList({
+  id,
+  items
+}) {
+  return {
+    "@type": "ItemList",
+    "@id": id,
+    numberOfItems: items.length,
+    itemListElement: items.map(
+      (item, index) => ({
+        "@type": "ListItem",
+        position: index + 1,
+        item: (() => {
+          if ("type" in item && item.type === "CollectionPage") {
+            const { id: id3, url: url2, name: name2 } = item;
+            return {
+              "@type": "CollectionPage",
+              "@id": id3,
+              url: url2,
+              ...name2 && { name: name2 }
+            };
+          }
+          const { entity, id: id2, url, name } = item;
+          return {
+            "@type": "WebPage",
+            "@id": id2,
+            url,
+            ...name && { name },
+            mainEntity: {
+              "@type": entity.type,
+              "@id": entity.id,
+              ...entity.name && { name: entity.name },
+              ...entity.description && {
+                description: entity.description
+              }
+            }
+          };
+        })()
+      })
+    )
+  };
+}
+
+export { buildTopicItemList };

package/dist/src/web/client/applications/structured-data/build/build-web-page.js

@@ -0,0 +1,51 @@
+import 'mime-types';
+import { findTranslation } from '../../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../../shared/utils/join-url.js';
+
+function createBuildWebPage({ storageUrl }) {
+  return function buildWebPage(pageIdentity, params) {
+    const {
+      locale,
+      webpageId,
+      pageUrl: url,
+      websiteId,
+      breadcrumbId
+    } = pageIdentity;
+    const { type = "WebPage", page, mainEntity } = params;
+    const { coverImage } = page || {};
+    const pageT = findTranslation(page?.translations, locale);
+    const seoMetadata = findTranslation(page?.seoMetadatas, locale);
+    const coverImageT = findTranslation(coverImage?.translations, locale);
+    const name = seoMetadata?.title ?? pageT?.title;
+    const description = seoMetadata?.description ?? pageT?.description;
+    return {
+      "@type": type,
+      "@id": webpageId,
+      url,
+      inLanguage: locale,
+      ...name && { name },
+      ...description && { description },
+      ...coverImage && {
+        primaryImageOfPage: {
+          "@type": "ImageObject",
+          "@id": `image:${coverImage.id}`,
+          url: joinUrl(storageUrl, coverImage.key),
+          ...coverImageT.alt && { caption: coverImageT.alt },
+          ...coverImage.width && { width: coverImage.width },
+          ...coverImage.height && { height: coverImage.height }
+        }
+      },
+      isPartOf: {
+        "@id": websiteId
+      },
+      breadcrumb: {
+        "@id": breadcrumbId
+      },
+      ...mainEntity && { mainEntity }
+    };
+  };
+}
+
+export { createBuildWebPage };

package/dist/src/web/client/applications/structured-data/build/build-website.js

@@ -0,0 +1,20 @@
+function createBuildWebsite({ siteConfig }) {
+  return function buildWebsite(pageIdentity) {
+    const { locale, websiteId, siteUrl } = pageIdentity;
+    const { name: siteName, description: siteDescription } = siteConfig.site;
+    const name = siteName[locale];
+    const description = siteDescription?.[locale];
+    return {
+      "@type": "WebSite",
+      "@id": websiteId,
+      url: String(siteUrl),
+      ...name && { name },
+      ...description && { description },
+      publisher: {
+        "@id": pageIdentity.publisherId
+      }
+    };
+  };
+}
+
+export { createBuildWebsite };

package/dist/src/web/client/applications/structured-data/create-graph.js

@@ -0,0 +1,18 @@
+function createGraph(...inputs) {
+  const nodes = inputs.flat().filter(Boolean);
+  const map = /* @__PURE__ */ new Map();
+  for (const [index, node] of nodes.entries()) {
+    const id = node["@id"];
+    if (id) {
+      if (!map.has(id)) map.set(id, node);
+    } else {
+      map.set(`__anonymous_node_${index}`, node);
+    }
+  }
+  return {
+    "@context": "https://schema.org",
+    "@graph": Array.from(map.values())
+  };
+}
+
+export { createGraph };

package/dist/src/web/client/applications/structured-data/get-page-identity.js

@@ -0,0 +1,46 @@
+import 'mime-types';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+
+function createGetPageIdentity({
+  siteConfig,
+  intorConfig,
+  localizePathname
+}) {
+  return function getPageIdentity(rawPathname, locale) {
+    const siteUrl = String(siteConfig.site.url);
+    const pathnameMap = /* @__PURE__ */ new Map();
+    for (const locale2 of siteConfig.locales) {
+      const { pathname: pathname2 } = localizePathname(rawPathname, intorConfig, locale2);
+      pathnameMap.set(locale2, pathname2);
+    }
+    const pathname = pathnameMap.get(locale);
+    const alternateUrlMap = {};
+    for (const [locale2, pathname2] of pathnameMap) {
+      alternateUrlMap[locale2] = joinUrl(siteUrl, pathname2);
+    }
+    const pageUrl = joinUrl(siteUrl, pathname);
+    const alternateUrls = {
+      default: alternateUrlMap[siteConfig.defaultLocale],
+      locales: alternateUrlMap
+    };
+    return {
+      // routing
+      pathname: pathnameMap.get(locale),
+      locale,
+      // urls
+      siteUrl,
+      pageUrl,
+      alternateUrls,
+      // global (use siteUrl)
+      websiteId: `${siteUrl}#website`,
+      publisherId: `${siteUrl}#publisher`,
+      // page
+      webpageId: `${pageUrl}#webpage`,
+      breadcrumbId: `${pageUrl}#breadcrumb`
+    };
+  };
+}
+
+export { createGetPageIdentity };

package/dist/src/web/client/applications/structured-data/resolve-topic-item-list/map-category-item.js

@@ -0,0 +1,27 @@
+import 'mime-types';
+import { findTranslation } from '../../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../../shared/utils/join-url.js';
+
+function createMapCategoryItem({
+  getPageIdentity
+}) {
+  return function mapCategoryItem({
+    item,
+    locale,
+    pagePathname
+  }) {
+    const t = findTranslation(item.translations, locale);
+    const name = t?.title;
+    const identity = getPageIdentity(joinUrl(pagePathname, item.slug), locale);
+    return {
+      type: "CollectionPage",
+      id: identity.webpageId,
+      url: identity.pageUrl,
+      ...name && { name }
+    };
+  };
+}
+
+export { createMapCategoryItem };

package/dist/src/web/client/applications/structured-data/resolve-topic-item-list/map-post-item.js

@@ -0,0 +1,34 @@
+import 'mime-types';
+import { findTranslation } from '../../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../../shared/utils/join-url.js';
+
+function createMapPostItem({
+  getPageIdentity
+}) {
+  return function mapPostItem({
+    item,
+    locale,
+    pagePathname,
+    entityType
+  }) {
+    const t = findTranslation(item.translations, locale);
+    const name = t?.title;
+    const description = t?.description;
+    const identity = getPageIdentity(joinUrl(pagePathname, item.slug), locale);
+    return {
+      id: identity.webpageId,
+      url: identity.pageUrl,
+      ...name && { name },
+      entity: {
+        type: entityType,
+        id: `${identity.pageUrl}#${entityType.toLowerCase()}`,
+        ...name && { name },
+        ...description && { description }
+      }
+    };
+  };
+}
+
+export { createMapPostItem };

package/dist/src/web/client/applications/structured-data/resolve-topic-item-list/resolve-topic-item-list.js

@@ -0,0 +1,26 @@
+function createResolveTopicItemList({
+  mapCategoryItem,
+  mapPostItem
+}) {
+  return function resolveTopicItemList({
+    listMode,
+    entityType = "Article",
+    pageIdentity,
+    rawItems,
+    pagePathname
+  }) {
+    const { pageUrl, locale } = pageIdentity;
+    const itemListId = `${pageUrl}#${listMode === "category" ? "category-list" : "post-list"}`;
+    const items = listMode === "category" ? rawItems.map(
+      (item) => mapCategoryItem({ item, locale, pagePathname })
+    ) : rawItems.map(
+      (item) => mapPostItem({ item, locale, pagePathname, entityType })
+    );
+    return {
+      itemListId,
+      items
+    };
+  };
+}
+
+export { createResolveTopicItemList };

package/dist/src/web/client/interfaces/components/json-ld.js

@@ -0,0 +1,21 @@
+import { jsx } from 'react/jsx-runtime';
+
+const serializeJsonLd = (data) => {
+  if (data == null) return "";
+  return JSON.stringify(data).replaceAll("<", String.raw`\u003c`).replaceAll(">", String.raw`\u003e`).replaceAll("&", String.raw`\u0026`);
+};
+function JsonLd({ data }) {
+  const isArray = Array.isArray(data);
+  if (!data || isArray && data.length === 0) return;
+  return /* @__PURE__ */ jsx(
+    "script",
+    {
+      type: "application/ld+json",
+      dangerouslySetInnerHTML: {
+        __html: serializeJsonLd(data)
+      }
+    }
+  );
+}
+
+export { JsonLd };

package/dist/src/web/server/applications/create-web-applications.js

@@ -0,0 +1,28 @@
+import { createNewInquiryEmail } from './emails/inquiry/create-new-inquiry-email.js';
+import 'intor';
+import { createResolveUrls } from './metadata/resolve-urls.js';
+import { createBuildMetadata } from './metadata/build-metadata.js';
+
+function createWebApplications(input) {
+  const { coreServer, constants } = input;
+  const emailContext = {
+    coreServer,
+    constants
+  };
+  const newInquiryEmail = createNewInquiryEmail(emailContext);
+  const resolveUrls = createResolveUrls(constants);
+  const buildMetadata = createBuildMetadata(constants);
+  return {
+    // emails
+    emails: {
+      newInquiryEmail
+    },
+    // metadata
+    metadata: {
+      resolveUrls,
+      buildMetadata
+    }
+  };
+}
+
+export { createWebApplications };

package/dist/src/web/server/applications/emails/inquiry/create-new-inquiry-email.js

@@ -0,0 +1,34 @@
+import '../../../../../constants/paths/auth.js';
+import '../../../../../constants/paths/main.js';
+import '../../../../../constants/paths/resources.js';
+import '../../../../../constants/redirect-paths.js';
+import { EMAILS } from '../../../../../constants/emails.js';
+
+function createNewInquiryEmail(ctx) {
+  const {
+    coreServer: { infrastructure },
+    constants
+  } = ctx;
+  async function generateHtml(replacements) {
+    return await infrastructure.email.renderEmailTemplate(
+      EMAILS.newInquiry.filePath,
+      replacements
+    );
+  }
+  async function send({ translator, email }) {
+    const html = await generateHtml({
+      url: `${constants.webUrl}/cms/dashboard/inquiry`
+    });
+    return infrastructure.email.sendEmail({
+      to: email,
+      subject: translator.t("email.new-inquiry.text"),
+      html
+    });
+  }
+  return {
+    generateHtml,
+    send
+  };
+}
+
+export { createNewInquiryEmail };

package/dist/src/web/server/applications/metadata/build-alternate-pathnames.js

@@ -0,0 +1,18 @@
+import { localizePathname } from 'intor';
+
+function buildAlternatePathnames({
+  rawPathname,
+  intorConfig,
+  locales,
+  defaultLocale
+}) {
+  const result = {};
+  for (const locale of locales) {
+    const { pathname } = localizePathname(rawPathname, intorConfig, locale);
+    result[locale] = pathname;
+  }
+  result["x-default"] = result[defaultLocale] ?? "";
+  return result;
+}
+
+export { buildAlternatePathnames };

package/dist/src/web/server/applications/metadata/build-metadata.js

@@ -0,0 +1,127 @@
+import 'mime-types';
+import { findTranslation } from '../../../../shared/translation/find-translation.js';
+import 'clsx';
+import 'tailwind-merge';
+import { joinUrl } from '../../../../shared/utils/join-url.js';
+import { toIsoTime } from '../../../../shared/utils/to-iso-time.js';
+import { buildAlternateMap } from './utils/build-alternate-map.js';
+import { buildOgImages } from './utils/build-og-image.js';
+import { ensureOgType } from './utils/ensure-og-type.js';
+import { ensureTwitterCard } from './utils/ensure-twitter-card.js';
+import { sanitizeStringArray } from './utils/sanitize-string-array.js';
+import { toOgLocale } from './utils/to-og-locale.js';
+
+function createBuildMetadata({
+  siteConfig,
+  storageUrl
+}) {
+  return function buildMetadata(urls, post, locale, isArticle = false) {
+    const { defaultLocale, locales, site } = siteConfig;
+    const resolvedLocale = locale || defaultLocale;
+    const seoMetadata = findTranslation(post?.seoMetadatas, locale);
+    const authorT = findTranslation(post?.author?.translations, locale);
+    const coverImageT = findTranslation(post?.coverImage?.translations, locale);
+    const tags = sanitizeStringArray(
+      post?.tags.map((t) => findTranslation(t.translations, locale).title)
+    );
+    const articleCoverImageUrl = joinUrl(storageUrl, post?.coverImage?.key);
+    return {
+      metadataBase: site.url,
+      // -----------------------------------------------------------------------
+      // Basic
+      // -----------------------------------------------------------------------
+      title: seoMetadata.title || site.name[resolvedLocale],
+      description: seoMetadata.description || site.description[resolvedLocale],
+      // identity
+      ...isArticle ? {
+        authors: [
+          {
+            name: seoMetadata.author || authorT.authorName || void 0,
+            url: authorT.url || void 0
+          }
+        ]
+      } : {},
+      // url
+      alternates: {
+        canonical: seoMetadata.canonical || urls.canonical,
+        languages: seoMetadata.alternate?.length ? buildAlternateMap(seoMetadata.alternate) : urls.alternates
+      },
+      // robots
+      robots: seoMetadata.robots || {
+        index: true,
+        follow: true,
+        "max-image-preview": "large"
+      },
+      // -----------------------------------------------------------------------
+      // Open Graph
+      // -----------------------------------------------------------------------
+      openGraph: {
+        title: seoMetadata.ogTitle || void 0,
+        description: seoMetadata.ogDescription || void 0,
+        // url
+        url: seoMetadata.ogUrl || seoMetadata.canonical || void 0,
+        // identity
+        type: ensureOgType(
+          isArticle ? "article" : "website",
+          seoMetadata.ogType
+        ),
+        siteName: seoMetadata.ogSiteName || site.name[resolvedLocale],
+        // image
+        images: isArticle ? buildOgImages({
+          url: seoMetadata.ogImage || articleCoverImageUrl,
+          secureUrl: seoMetadata.ogImage || articleCoverImageUrl,
+          alt: seoMetadata.ogImageAlt || coverImageT.alt,
+          type: seoMetadata.ogImageType,
+          width: seoMetadata.ogImageWidth,
+          height: seoMetadata.ogImageHeight
+        }) : (
+          // is `website`
+          seoMetadata.ogImage ? buildOgImages({
+            url: seoMetadata.ogImage,
+            secureUrl: seoMetadata.ogImage,
+            alt: seoMetadata.ogImageAlt,
+            type: seoMetadata.ogImageType,
+            width: seoMetadata.ogImageWidth,
+            height: seoMetadata.ogImageHeight
+          }) : (
+            // default
+            buildOgImages({
+              url: site.defaultImage.url,
+              secureUrl: site.defaultImage.url,
+              alt: site.defaultImage.alt,
+              type: site.defaultImage.mimeType,
+              width: site.defaultImage.width,
+              height: site.defaultImage.height
+            })
+          )
+        ),
+        // locale
+        locale: seoMetadata.ogLocale || toOgLocale(resolvedLocale),
+        alternateLocale: sanitizeStringArray(
+          seoMetadata.ogLocaleAlternate?.length ? seoMetadata.ogLocaleAlternate : locales.filter((l) => l !== resolvedLocale).map(toOgLocale)
+        ),
+        // article
+        ...isArticle ? {
+          publishedTime: toIsoTime(seoMetadata.ogArticlePublishedTime),
+          modifiedTime: toIsoTime(seoMetadata.ogArticleModifiedTime),
+          authors: [
+            seoMetadata.ogArticleAuthor || authorT.authorName
+          ].filter(Boolean),
+          section: seoMetadata.ogArticleSection,
+          tags: sanitizeStringArray(seoMetadata.ogArticleTag) || tags
+        } : {}
+      },
+      // -----------------------------------------------------------------------
+      // Twitter
+      // -----------------------------------------------------------------------
+      twitter: {
+        card: ensureTwitterCard("summary_large_image", seoMetadata.twitterCard),
+        // identity
+        site: seoMetadata.twitterSite || void 0,
+        creator: seoMetadata.twitterCreator || void 0
+      }
+    };
+  };
+}
+
+export { createBuildMetadata };