lightnet 4.0.8 → 4.1.1

package/src/pages/details-page/utils/create-content-metadata.ts

@@ -1,8 +1,4 @@
-import {
-  type TranslateMapFn,
-  type TranslationMap,
-} from "../../../i18n/translate-map"
-import { isExternalUrl } from "../../../utils/urls"
+import { isExternalUrl } from "../../../utils/is-external-url"
 
 export type UrlType =
   | "link"
@@ -15,49 +11,45 @@ export type UrlType =
 
 const KNOWN_EXTENSIONS: Record<
   string,
-  { type: UrlType; canBeOpened?: boolean } | undefined
+  { type: UrlType; isDownload?: boolean } | undefined
 > = {
-  htm: { type: "link", canBeOpened: true },
-  html: { type: "link", canBeOpened: true },
-  php: { type: "link", canBeOpened: true },
-  json: { type: "source", canBeOpened: true },
-  xml: { type: "source", canBeOpened: true },
-  md: { type: "source", canBeOpened: true },
-  svg: { type: "image", canBeOpened: true },
-  jpg: { type: "image", canBeOpened: true },
-  jpeg: { type: "image", canBeOpened: true },
-  png: { type: "image", canBeOpened: true },
-  gif: { type: "image", canBeOpened: true },
-  ico: { type: "image", canBeOpened: true },
-  webp: { type: "image", canBeOpened: true },
-  mp3: { type: "audio", canBeOpened: true },
-  wav: { type: "audio", canBeOpened: true },
-  aac: { type: "audio", canBeOpened: true },
-  ogg: { type: "audio", canBeOpened: true },
-  mp4: { type: "video", canBeOpened: true },
-  webm: { type: "video", canBeOpened: true },
-  ogv: { type: "video", canBeOpened: true },
-  pdf: { type: "text", canBeOpened: true },
-  txt: { type: "text", canBeOpened: true },
-  epub: { type: "text" },
-  zip: { type: "package" },
-  ppt: { type: "text" },
-  pptx: { type: "text" },
-  doc: { type: "text" },
-  docx: { type: "text" },
+  htm: { type: "link" },
+  html: { type: "link" },
+  php: { type: "link" },
+  json: { type: "source" },
+  xml: { type: "source" },
+  md: { type: "source" },
+  svg: { type: "image" },
+  jpg: { type: "image" },
+  jpeg: { type: "image" },
+  png: { type: "image" },
+  gif: { type: "image" },
+  ico: { type: "image" },
+  webp: { type: "image" },
+  mp3: { type: "audio" },
+  wav: { type: "audio" },
+  aac: { type: "audio" },
+  ogg: { type: "audio" },
+  mp4: { type: "video" },
+  webm: { type: "video" },
+  ogv: { type: "video" },
+  pdf: { type: "text" },
+  txt: { type: "text" },
+  epub: { type: "text", isDownload: true },
+  zip: { type: "package", isDownload: true },
+  ppt: { type: "text", isDownload: true },
+  pptx: { type: "text", isDownload: true },
+  doc: { type: "text", isDownload: true },
+  docx: { type: "text", isDownload: true },
 } as const
 
-export function createContentMetadata(
-  {
-    url,
-    label: customLabel,
-  }: {
-    url: string
-    label?: TranslationMap
-  },
-  tMap: TranslateMapFn,
-  context: { path: (string | number)[] },
-) {
+export function createContentMetadata({
+  url,
+  labelText: customLabel,
+}: {
+  url: string
+  labelText?: string
+}) {
   const isExternal = isExternalUrl(url)
   const path = isExternal ? new URL(url).pathname : url
 
@@ -72,24 +64,16 @@ export function createContentMetadata(
     ? lastPathSegment.slice(0, -(extension.length + 1))
     : undefined
 
-  const labelText =
-    (customLabel &&
-      tMap(customLabel, {
-        path: [...context.path, "label"],
-      })) ??
-    fileName ??
-    linkName
+  const labelText = customLabel ?? fileName ?? linkName
   const type = KNOWN_EXTENSIONS[extension]?.type ?? "link"
-  const canBeOpened =
-    !hasExtension || !!KNOWN_EXTENSIONS[extension]?.canBeOpened
+  const isDownload = KNOWN_EXTENSIONS[extension]?.isDownload
 
   return {
     url,
     extension,
     isExternal,
     labelText,
-    canBeOpened,
+    isDownload,
     type,
-    target: isExternal ? "_blank" : "_self",
   } as const
 }

package/src/pages/search-page/api/search.ts

@@ -1,8 +1,8 @@
 import type { APIRoute } from "astro"
 import { getImage } from "astro:assets"
 
-import type { MediaItemEntry } from "../../../content/content-schema"
 import { getMediaItems } from "../../../content/get-media-items"
+import type { MediaItemEntry } from "../../../content/schema/media-item"
 import { markdownToText } from "../../../utils/markdown"
 import type { SearchItem } from "./search-response"
 

package/src/pages/search-page/components/SearchFilter.astro

@@ -2,22 +2,22 @@
 import config from "virtual:lightnet/config"
 
 import { getUsedCategories } from "../../../content/get-categories"
-import { getUsedLanguages } from "../../../content/get-languages"
+import { getContentLanguages } from "../../../content/get-languages"
 import { getUsedMediaTypes } from "../../../content/get-media-types"
 import { prepareI18nConfig } from "../../../i18n/react/prepare-i18n-config"
 import SearchFilterReact from "./SearchFilter.tsx"
 
-const { currentLocale, tMap } = Astro.locals.i18n
+const { currentLocale, tConfigField, tContentField } = Astro.locals.i18n
 
-const categories = (await getUsedCategories(currentLocale, tMap)).map(
+const categories = (await getUsedCategories(currentLocale, tContentField)).map(
   ({ id, labelText }) => ({ id, labelText }),
 )
 
-const mediaTypes = (await getUsedMediaTypes(currentLocale, tMap)).map(
+const mediaTypes = (await getUsedMediaTypes(currentLocale, tContentField)).map(
   ({ id, labelText }) => ({ id, labelText }),
 )
 
-const languages = (await getUsedLanguages(currentLocale, tMap)).map(
+const languages = (await getContentLanguages(currentLocale, tConfigField)).map(
   ({ code: id, labelText }) => ({ id, labelText }),
 )
 

package/src/pages/search-page/components/SearchList.astro

@@ -2,42 +2,45 @@
 import { getCollection } from "astro:content"
 
 import { getUsedCategories } from "../../../content/get-categories"
-import { getUsedLanguages } from "../../../content/get-languages"
-import { getMediaTypes } from "../../../content/get-media-types"
+import { getContentLanguages } from "../../../content/get-languages"
+import { getTranslatedMediaTypes } from "../../../content/get-media-types"
 import { prepareI18nConfig } from "../../../i18n/react/prepare-i18n-config"
 import SearchListReact from "./SearchList.tsx"
 
-const { currentLocale, tMap } = Astro.locals.i18n
+const { currentLocale, tContentField, tConfigField } = Astro.locals.i18n
 
 const categories: Record<string, string> = {}
-for (const { id, labelText } of await getUsedCategories(currentLocale, tMap)) {
+for (const { id, labelText } of await getUsedCategories(
+  currentLocale,
+  tContentField,
+)) {
   categories[id] = labelText
 }
 
 const mediaTypes = Object.fromEntries(
-  (await getMediaTypes()).map((type) => [
-    type.id,
-    {
-      labelText: tMap(type.data.label, {
-        path: ["media-types", type.id, "label"],
-      }),
-      icon: type.data.icon,
-      coverImageStyle: type.data.coverImageStyle,
-    },
-  ]),
+  (await getTranslatedMediaTypes(currentLocale, tContentField)).map(
+    ({ labelText, icon, coverImageStyle, id }) => [
+      id,
+      {
+        labelText,
+        icon,
+        coverImageStyle,
+      },
+    ],
+  ),
 )
 
-const contentLanguagesList = await getUsedLanguages(currentLocale, tMap)
+const contentLanguages = await getContentLanguages(currentLocale, tConfigField)
 const languages = Object.fromEntries(
-  contentLanguagesList.map((language) => [
-    language.code,
-    { direction: language.direction, labelText: language.labelText },
+  contentLanguages.map(({ code, direction, labelText }) => [
+    code,
+    { direction, labelText },
   ]),
 )
 
 const mediaItemsTotal = (await getCollection("media")).length
 
-const showLanguage = contentLanguagesList.length > 1
+const showLanguage = contentLanguages.length > 1
 
 const i18nConfig = prepareI18nConfig(Astro.locals.i18n, [
   "ln.search.no-results",

package/src/utils/is-external-url.ts

@@ -0,0 +1,34 @@
+import config from "virtual:lightnet/config"
+
+import { parseUrl } from "./urls"
+
+/**
+ * Test if a given url is outside this site.
+ * Will return false if the url is relative or if it
+ * starts with the site config from astro config.
+ *
+ * @param url to test
+ * @returns is the url external?
+ */
+export function isExternalUrl(url: string) {
+  const parsedUrl = parseUrl(url)
+  if (!parsedUrl) {
+    return false
+  }
+
+  if (config.internalDomains.includes(parsedUrl.hostname)) {
+    return false
+  }
+
+  const { SITE: site } = import.meta.env
+  if (!site) {
+    return true
+  }
+
+  const parsedSiteUrl = parseUrl(site)
+  if (!parsedSiteUrl) {
+    return true
+  }
+
+  return !parsedUrl.href.startsWith(parsedSiteUrl.href)
+}

package/src/utils/link-attributes.ts

@@ -0,0 +1,10 @@
+import { isExternalUrl } from "./is-external-url"
+
+export function getLinkAttributes(href: string) {
+  const isExternal = isExternalUrl(href)
+  return {
+    href,
+    target: isExternal ? "_blank" : "_self",
+    rel: isExternal ? "noopener noreferrer" : undefined,
+  }
+}

package/src/utils/paths.ts

@@ -1,3 +1,5 @@
+import { isAbsoluteUrl } from "./urls"
+
 /**
  * Prefix a site-internal path with Astro's configured base path.
  *
@@ -91,6 +93,10 @@ export function searchPagePath(
  * @returns resolved path. Eg. '/en/about' for input "en" and "/about"
  */
 export function localizePath(locale: string | undefined, path: string) {
+  if (isAbsoluteUrl(path)) {
+    return path
+  }
+
   return pathWithBase(
     `${locale ? `/${locale}` : ""}/${path.replace(/^\//, "")}`,
   )

package/src/utils/urls.ts

@@ -1,28 +1,16 @@
-import config from "virtual:lightnet/config"
-
-/**
- * Test if a given url is outside this site.
- * Will return false if the url is relative or if it
- * starts with the site config from astro config.
- *
- * @param url to test
- * @returns is the url external?
- */
-export function isExternalUrl(url: string) {
-  let parsedUrl
+export function parseUrl(url: string) {
   try {
-    // test if url is absolute
-    parsedUrl = new URL(url)
+    return new URL(url)
   } catch {
-    // url is relative
-    return false
-  }
-  if (config.internalDomains.includes(parsedUrl.hostname)) {
-    return false
-  }
-  const { SITE: site } = import.meta.env
-  if (!site) {
-    return true
+    // Support host-like values such as `example.com` without treating plain paths as external.
+    if (/^(localhost(?::\d+)?|[^/\s]+\.[^/\s]+)(?:[/?#]|$)/.test(url)) {
+      return new URL(`https://${url}`)
+    }
+
+    return null
   }
-  return !url.startsWith(site)
+}
+
+export function isAbsoluteUrl(url: string) {
+  return !!parseUrl(url)
 }

package/src/astro-integration/validators/validate-inline-translations.ts

@@ -1,51 +0,0 @@
-import { z } from "astro/zod"
-
-export const validateInlineTranslations = (
-  config: {
-    title: Record<string, string>
-    languages: { label: Record<string, string> }[]
-    mainMenu?: { label: Record<string, string> }[]
-    logo?: { alt?: Record<string, string> }
-  },
-  locales: string[],
-  defaultLocale: string,
-  ctx: z.RefinementCtx,
-) => {
-  const validateInlineTranslation = (
-    inlineTranslation: Record<string, string> | undefined,
-    path: (string | number)[],
-  ) => {
-    if (!inlineTranslation) {
-      return
-    }
-
-    if (!(defaultLocale in inlineTranslation)) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Missing translation for default locale "${defaultLocale}"`,
-        path: [...path, defaultLocale],
-      })
-    }
-
-    for (const locale of Object.keys(inlineTranslation)) {
-      if (locales.includes(locale)) {
-        continue
-      }
-
-      ctx.addIssue({
-        code: "custom",
-        message: `Invalid locale "${locale}". Inline translations only support configured site locales: ${locales.join(", ")}`,
-        path: [...path, locale],
-      })
-    }
-  }
-
-  validateInlineTranslation(config.title, ["title"])
-  for (const [index, language] of config.languages.entries()) {
-    validateInlineTranslation(language.label, ["languages", index, "label"])
-  }
-  for (const [index, link] of (config.mainMenu ?? []).entries()) {
-    validateInlineTranslation(link.label, ["mainMenu", index, "label"])
-  }
-  validateInlineTranslation(config.logo?.alt, ["logo", "alt"])
-}